iso20022_common/

common.rs

// Open Payment Message Parsing Library
// https://github.com/Open-Payments/iso20022-rs
//
// This library is designed to parse message formats based on the ISO 20022 standards,
// including but not limited to FedNow messages. It supports various financial message types,
// such as customer credit transfers, payment status reports, administrative notifications, 
// and other ISO 20022 messages, using Serde for efficient serialization and deserialization.
//
// Copyright (c) 2024 Open Payments
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// You may obtain a copy of this library at
// https://github.com/Open-Payments/iso20022-rs

#![allow(unused_imports)]
use regex::Regex;

#[cfg(feature = "derive_serde")]
use serde::{Deserialize, Serialize};
use crate::ValidationError;


// AbnormalValuesData4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AbnormalValuesData4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtyId") )]
	pub ctr_pty_id: CounterpartyData92,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfDerivsRptd") )]
	pub nb_of_derivs_rptd: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfDerivsRptdWthOtlrs") )]
	pub nb_of_derivs_rptd_wth_otlrs: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxDtls", skip_serializing_if = "Option::is_none") )]
	pub tx_dtls: Option<Vec<AbnormalValuesTransactionData2>>,
}

impl AbnormalValuesData4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.ctr_pty_id.validate()?;
		if let Some(ref vec) = self.tx_dtls { for item in vec { item.validate()? } }
		Ok(())
	}
}


// AbnormalValuesTransactionData2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AbnormalValuesTransactionData2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxId") )]
	pub tx_id: TradeTransactionIdentification24,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtnlAmt", skip_serializing_if = "Option::is_none") )]
	pub ntnl_amt: Option<NotionalAmountLegs5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtnlQty", skip_serializing_if = "Option::is_none") )]
	pub ntnl_qty: Option<NotionalQuantityLegs5>,
}

impl AbnormalValuesTransactionData2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tx_id.validate()?;
		if let Some(ref val) = self.ntnl_amt { val.validate()? }
		if let Some(ref val) = self.ntnl_qty { val.validate()? }
		Ok(())
	}
}


// Absolute1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Absolute1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Unit") )]
	pub unit: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Qty") )]
	pub qty: f64,
}

impl Absolute1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.unit.chars().count() < 1 {
			return Err(ValidationError::new(1001, "unit is shorter than the minimum length of 1".to_string()));
		}
		if self.unit.chars().count() > 35 {
			return Err(ValidationError::new(1002, "unit exceeds the maximum length of 35".to_string()));
		}
		Ok(())
	}
}


// AcceptanceResult6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AcceptanceResult6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Accptd") )]
	pub accptd: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RjctRsn", skip_serializing_if = "Option::is_none") )]
	pub rjct_rsn: Option<MandateReason1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlRjctRsnInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_rjct_rsn_inf: Option<Vec<String>>,
}

impl AcceptanceResult6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rjct_rsn { val.validate()? }
		if let Some(ref vec) = self.addtl_rjct_rsn_inf {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "addtl_rjct_rsn_inf is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 105 {
					return Err(ValidationError::new(1002, "addtl_rjct_rsn_inf exceeds the maximum length of 105".to_string()));
				}
			}
		}
		Ok(())
	}
}


// AcceptedReason7Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AcceptedReason7Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification36>,
}

impl AcceptedReason7Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// AcceptedReason8Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AcceptedReason8Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NoSpcfdRsn", skip_serializing_if = "Option::is_none") )]
	pub no_spcfd_rsn: Option<NoReasonCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<AcceptedReason7Choice>,
}

impl AcceptedReason8Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.no_spcfd_rsn { val.validate()? }
		if let Some(ref val) = self.rsn { val.validate()? }
		Ok(())
	}
}


// AcceptedStatusReason1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AcceptedStatusReason1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<AcceptedStatusReason1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification36>,
}

impl AcceptedStatusReason1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// AcceptedStatusReason1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AcceptedStatusReason1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "PLAC") )]
	CodePLAC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SECT") )]
	CodeSECT,
}

impl AcceptedStatusReason1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AcceptedStatusReason7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AcceptedStatusReason7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn") )]
	pub rsn: AcceptedReason8Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlRsnInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_rsn_inf: Option<String>,
}

impl AcceptedStatusReason7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.rsn.validate()?;
		if let Some(ref val) = self.addtl_rsn_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_rsn_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 210 {
				return Err(ValidationError::new(1002, "addtl_rsn_inf exceeds the maximum length of 210".to_string()));
			}
		}
		Ok(())
	}
}


// Account23 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Account23 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctId") )]
	pub acct_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdAcctDtls", skip_serializing_if = "Option::is_none") )]
	pub rltd_acct_dtls: Option<GenericIdentification1>,
}

impl Account23 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.acct_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "acct_id is shorter than the minimum length of 1".to_string()));
		}
		if self.acct_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "acct_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.rltd_acct_dtls { val.validate()? }
		Ok(())
	}
}


// Account32 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Account32 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcr") )]
	pub acct_svcr: PartyIdentification125Choice,
}

impl Account32 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
			}
		}
		self.acct_svcr.validate()?;
		Ok(())
	}
}


// AccountAndParties3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountAndParties3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: CashAccount43,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstgtdPties") )]
	pub invstgtd_pties: InvestigatedParties1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AuthrtyReqTp") )]
	pub authrty_req_tp: Vec<AuthorityRequestType1>,
}

impl AccountAndParties3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.id.validate()?;
		self.invstgtd_pties.validate()?;
		for item in &self.authrty_req_tp { item.validate()? }
		Ok(())
	}
}


// AccountCashEntryReturnCriteria3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountCashEntryReturnCriteria3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtryRefInd", skip_serializing_if = "Option::is_none") )]
	pub ntry_ref_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctTpInd", skip_serializing_if = "Option::is_none") )]
	pub acct_tp_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtryAmtInd", skip_serializing_if = "Option::is_none") )]
	pub ntry_amt_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctCcyInd", skip_serializing_if = "Option::is_none") )]
	pub acct_ccy_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtryStsInd", skip_serializing_if = "Option::is_none") )]
	pub ntry_sts_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtryDtInd", skip_serializing_if = "Option::is_none") )]
	pub ntry_dt_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcrInd", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctOwnrInd", skip_serializing_if = "Option::is_none") )]
	pub acct_ownr_ind: Option<bool>,
}

impl AccountCashEntryReturnCriteria3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AccountContract2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountContract2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrgtGoLiveDt", skip_serializing_if = "Option::is_none") )]
	pub trgt_go_live_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrgtClsgDt", skip_serializing_if = "Option::is_none") )]
	pub trgt_clsg_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UrgcyFlg", skip_serializing_if = "Option::is_none") )]
	pub urgcy_flg: Option<bool>,
}

impl AccountContract2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AccountContract3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountContract3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrgtGoLiveDt", skip_serializing_if = "Option::is_none") )]
	pub trgt_go_live_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrgtClsgDt", skip_serializing_if = "Option::is_none") )]
	pub trgt_clsg_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GoLiveDt", skip_serializing_if = "Option::is_none") )]
	pub go_live_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClsgDt", skip_serializing_if = "Option::is_none") )]
	pub clsg_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UrgcyFlg", skip_serializing_if = "Option::is_none") )]
	pub urgcy_flg: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RmvlInd", skip_serializing_if = "Option::is_none") )]
	pub rmvl_ind: Option<bool>,
}

impl AccountContract3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AccountContract4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountContract4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrgtClsgDt", skip_serializing_if = "Option::is_none") )]
	pub trgt_clsg_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UrgcyFlg", skip_serializing_if = "Option::is_none") )]
	pub urgcy_flg: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RmvlInd", skip_serializing_if = "Option::is_none") )]
	pub rmvl_ind: Option<bool>,
}

impl AccountContract4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AccountCriteria4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountCriteria4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "QryNm", skip_serializing_if = "Option::is_none") )]
	pub qry_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NewCrit", skip_serializing_if = "Option::is_none") )]
	pub new_crit: Option<AccountCriteria8>,
}

impl AccountCriteria4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.qry_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "qry_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "qry_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.new_crit { val.validate()? }
		Ok(())
	}
}


// AccountCriteria8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountCriteria8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NewQryNm", skip_serializing_if = "Option::is_none") )]
	pub new_qry_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SchCrit", skip_serializing_if = "Option::is_none") )]
	pub sch_crit: Option<Vec<CashAccountSearchCriteria8>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RtrCrit", skip_serializing_if = "Option::is_none") )]
	pub rtr_crit: Option<CashAccountReturnCriteria5>,
}

impl AccountCriteria8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.new_qry_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "new_qry_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "new_qry_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref vec) = self.sch_crit { for item in vec { item.validate()? } }
		if let Some(ref val) = self.rtr_crit { val.validate()? }
		Ok(())
	}
}


// AccountDesignation1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountDesignation1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<Rank1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl AccountDesignation1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// AccountForAction1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountForAction1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: AccountIdentification4Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ccy") )]
	pub ccy: String,
}

impl AccountForAction1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.id.validate()?;
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.ccy) {
			return Err(ValidationError::new(1005, "ccy does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// AccountForAction2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountForAction2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: AccountIdentification4Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ccy") )]
	pub ccy: String,
}

impl AccountForAction2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.id.validate()?;
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 70".to_string()));
			}
		}
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.ccy) {
			return Err(ValidationError::new(1005, "ccy does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// AccountIdentification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountIdentification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry") )]
	pub prtry: SimpleIdentificationInformation,
}

impl AccountIdentification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.prtry.validate()?;
		Ok(())
	}
}


// AccountIdentification26 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountIdentification26 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry") )]
	pub prtry: SimpleIdentificationInformation4,
}

impl AccountIdentification26 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.prtry.validate()?;
		Ok(())
	}
}


// AccountIdentification4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountIdentification4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "IBAN", skip_serializing_if = "Option::is_none") )]
	pub iban: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<GenericAccountIdentification1>,
}

impl AccountIdentification4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.iban {
			let pattern = Regex::new("[A-Z]{2,2}[0-9]{2,2}[a-zA-Z0-9]{1,30}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "iban does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.othr { val.validate()? }
		Ok(())
	}
}


// AccountIdentificationAndName5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountIdentificationAndName5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: AccountIdentification4Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
}

impl AccountIdentificationAndName5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.id.validate()?;
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// AccountIdentificationAndName7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountIdentificationAndName7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: CashAccountIdentification8Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
}

impl AccountIdentificationAndName7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.id.validate()?;
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// AccountIdentificationSearchCriteria2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountIdentificationSearchCriteria2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "EQ", skip_serializing_if = "Option::is_none") )]
	pub eq: Option<AccountIdentification4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CTTxt", skip_serializing_if = "Option::is_none") )]
	pub ct_txt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NCTTxt", skip_serializing_if = "Option::is_none") )]
	pub nct_txt: Option<String>,
}

impl AccountIdentificationSearchCriteria2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.eq { val.validate()? }
		if let Some(ref val) = self.ct_txt {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ct_txt is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "ct_txt exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.nct_txt {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nct_txt is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "nct_txt exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// AccountInterest4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountInterest4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<InterestType1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rate", skip_serializing_if = "Option::is_none") )]
	pub rate: Option<Vec<Rate4>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrToDt", skip_serializing_if = "Option::is_none") )]
	pub fr_to_dt: Option<DateTimePeriod1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tax", skip_serializing_if = "Option::is_none") )]
	pub tax: Option<TaxCharges2>,
}

impl AccountInterest4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref vec) = self.rate { for item in vec { item.validate()? } }
		if let Some(ref val) = self.fr_to_dt { val.validate()? }
		if let Some(ref val) = self.rsn {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rsn is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "rsn exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.tax { val.validate()? }
		Ok(())
	}
}


// AccountLevel1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AccountLevel1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "INTM") )]
	CodeINTM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SMRY") )]
	CodeSMRY,
}

impl AccountLevel1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AccountLevel2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AccountLevel2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "INTM") )]
	CodeINTM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SMRY") )]
	CodeSMRY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DETL") )]
	CodeDETL,
}

impl AccountLevel2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AccountManagementConfirmation5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountManagementConfirmation5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ConfTp") )]
	pub conf_tp: ConfirmationType1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctApplId", skip_serializing_if = "Option::is_none") )]
	pub acct_appl_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClntRef", skip_serializing_if = "Option::is_none") )]
	pub clnt_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtyRef", skip_serializing_if = "Option::is_none") )]
	pub ctr_pty_ref: Option<AdditionalReference13>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExstgAcctId", skip_serializing_if = "Option::is_none") )]
	pub exstg_acct_id: Option<Vec<Account23>>,
}

impl AccountManagementConfirmation5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.conf_tp.validate()?;
		if let Some(ref val) = self.acct_appl_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_appl_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acct_appl_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.clnt_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "clnt_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "clnt_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.ctr_pty_ref { val.validate()? }
		if let Some(ref vec) = self.exstg_acct_id { for item in vec { item.validate()? } }
		Ok(())
	}
}


// AccountManagementMessageReference5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountManagementMessageReference5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "LkdRef", skip_serializing_if = "Option::is_none") )]
	pub lkd_ref: Option<LinkedMessage5Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsReqTp") )]
	pub sts_req_tp: AccountManagementType3Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctApplId", skip_serializing_if = "Option::is_none") )]
	pub acct_appl_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExstgAcctId", skip_serializing_if = "Option::is_none") )]
	pub exstg_acct_id: Option<Account23>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstmtAcct", skip_serializing_if = "Option::is_none") )]
	pub invstmt_acct: Option<InvestmentAccount77>,
}

impl AccountManagementMessageReference5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.lkd_ref { val.validate()? }
		self.sts_req_tp.validate()?;
		if let Some(ref val) = self.acct_appl_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_appl_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acct_appl_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.exstg_acct_id { val.validate()? }
		if let Some(ref val) = self.invstmt_acct { val.validate()? }
		Ok(())
	}
}


// AccountManagementStatus1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AccountManagementStatus1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "RECE") )]
	CodeRECE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACCP") )]
	CodeACCP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EXEC") )]
	CodeEXEC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "STNP") )]
	CodeSTNP,
}

impl AccountManagementStatus1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AccountManagementStatusAndReason5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountManagementStatusAndReason5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts") )]
	pub sts: Status25Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsRsn", skip_serializing_if = "Option::is_none") )]
	pub sts_rsn: Option<Vec<AcceptedStatusReason1Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctApplId", skip_serializing_if = "Option::is_none") )]
	pub acct_appl_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExstgAcctId", skip_serializing_if = "Option::is_none") )]
	pub exstg_acct_id: Option<Vec<Account23>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctId", skip_serializing_if = "Option::is_none") )]
	pub acct_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSts", skip_serializing_if = "Option::is_none") )]
	pub acct_sts: Option<AccountStatus2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BlckdSts", skip_serializing_if = "Option::is_none") )]
	pub blckd_sts: Option<BlockedStatusReason2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FATCARptgDt", skip_serializing_if = "Option::is_none") )]
	pub fatca_rptg_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CRSRptgDt", skip_serializing_if = "Option::is_none") )]
	pub crs_rptg_dt: Option<String>,
}

impl AccountManagementStatusAndReason5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.sts.validate()?;
		if let Some(ref vec) = self.sts_rsn { for item in vec { item.validate()? } }
		if let Some(ref val) = self.acct_appl_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_appl_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acct_appl_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref vec) = self.exstg_acct_id { for item in vec { item.validate()? } }
		if let Some(ref val) = self.acct_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acct_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.acct_sts { val.validate()? }
		if let Some(ref val) = self.blckd_sts { val.validate()? }
		Ok(())
	}
}


// AccountManagementType2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AccountManagementType2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACCO") )]
	CodeACCO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACCM") )]
	CodeACCM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GACC") )]
	CodeGACC,
}

impl AccountManagementType2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AccountManagementType3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AccountManagementType3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACCM") )]
	CodeACCM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACCO") )]
	CodeACCO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GACC") )]
	CodeGACC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACST") )]
	CodeACST,
}

impl AccountManagementType3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AccountNotification22 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountNotification22 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtfctnPgntn", skip_serializing_if = "Option::is_none") )]
	pub ntfctn_pgntn: Option<Pagination1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ElctrncSeqNb", skip_serializing_if = "Option::is_none") )]
	pub elctrnc_seq_nb: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgSeq", skip_serializing_if = "Option::is_none") )]
	pub rptg_seq: Option<SequenceRange1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LglSeqNb", skip_serializing_if = "Option::is_none") )]
	pub lgl_seq_nb: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm", skip_serializing_if = "Option::is_none") )]
	pub cre_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrToDt", skip_serializing_if = "Option::is_none") )]
	pub fr_to_dt: Option<DateTimePeriod1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CpyDplctInd", skip_serializing_if = "Option::is_none") )]
	pub cpy_dplct_ind: Option<CopyDuplicate1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgSrc", skip_serializing_if = "Option::is_none") )]
	pub rptg_src: Option<ReportingSource1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Acct") )]
	pub acct: CashAccount43,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdAcct", skip_serializing_if = "Option::is_none") )]
	pub rltd_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Intrst", skip_serializing_if = "Option::is_none") )]
	pub intrst: Option<Vec<AccountInterest4>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxsSummry", skip_serializing_if = "Option::is_none") )]
	pub txs_summry: Option<TotalTransactions6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ntry", skip_serializing_if = "Option::is_none") )]
	pub ntry: Option<Vec<ReportEntry14>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlNtfctnInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_ntfctn_inf: Option<String>,
}

impl AccountNotification22 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.ntfctn_pgntn { val.validate()? }
		if let Some(ref val) = self.rptg_seq { val.validate()? }
		if let Some(ref val) = self.fr_to_dt { val.validate()? }
		if let Some(ref val) = self.cpy_dplct_ind { val.validate()? }
		if let Some(ref val) = self.rptg_src { val.validate()? }
		self.acct.validate()?;
		if let Some(ref val) = self.rltd_acct { val.validate()? }
		if let Some(ref vec) = self.intrst { for item in vec { item.validate()? } }
		if let Some(ref val) = self.txs_summry { val.validate()? }
		if let Some(ref vec) = self.ntry { for item in vec { item.validate()? } }
		if let Some(ref val) = self.addtl_ntfctn_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_ntfctn_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 500 {
				return Err(ValidationError::new(1002, "addtl_ntfctn_inf exceeds the maximum length of 500".to_string()));
			}
		}
		Ok(())
	}
}


// AccountNotification23 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountNotification23 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Acct", skip_serializing_if = "Option::is_none") )]
	pub acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctOwnr", skip_serializing_if = "Option::is_none") )]
	pub acct_ownr: Option<Party50Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcr", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdAcct", skip_serializing_if = "Option::is_none") )]
	pub rltd_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlAmt", skip_serializing_if = "Option::is_none") )]
	pub ttl_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XpctdValDt", skip_serializing_if = "Option::is_none") )]
	pub xpctd_val_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dbtr", skip_serializing_if = "Option::is_none") )]
	pub dbtr: Option<Party50Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgt", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Itm") )]
	pub itm: Vec<NotificationItem9>,
}

impl AccountNotification23 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.acct { val.validate()? }
		if let Some(ref val) = self.acct_ownr { val.validate()? }
		if let Some(ref val) = self.acct_svcr { val.validate()? }
		if let Some(ref val) = self.rltd_acct { val.validate()? }
		if let Some(ref val) = self.ttl_amt { val.validate()? }
		if let Some(ref val) = self.dbtr { val.validate()? }
		if let Some(ref val) = self.dbtr_agt { val.validate()? }
		if let Some(ref val) = self.intrmy_agt { val.validate()? }
		for item in &self.itm { item.validate()? }
		Ok(())
	}
}


// AccountOpeningType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountOpeningType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<AccountOpeningType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl AccountOpeningType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// AccountOpeningType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AccountOpeningType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "NEWA") )]
	CodeNEWA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SUPA") )]
	CodeSUPA,
}

impl AccountOpeningType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AccountOrBusinessError6Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountOrBusinessError6Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Acct", skip_serializing_if = "Option::is_none") )]
	pub acct: Option<CashAccountData1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizErr", skip_serializing_if = "Option::is_none") )]
	pub biz_err: Option<Vec<ErrorHandling5>>,
}

impl AccountOrBusinessError6Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.acct { val.validate()? }
		if let Some(ref vec) = self.biz_err { for item in vec { item.validate()? } }
		Ok(())
	}
}


// AccountOrOperationalError6Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountOrOperationalError6Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctRpt", skip_serializing_if = "Option::is_none") )]
	pub acct_rpt: Option<Vec<AccountReport35>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OprlErr", skip_serializing_if = "Option::is_none") )]
	pub oprl_err: Option<Vec<ErrorHandling5>>,
}

impl AccountOrOperationalError6Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.acct_rpt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.oprl_err { for item in vec { item.validate()? } }
		Ok(())
	}
}


// AccountOwner3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountOwner3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "IndvOwnrId", skip_serializing_if = "Option::is_none") )]
	pub indv_ownr_id: Option<IndividualPersonIdentification3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgOwnrId", skip_serializing_if = "Option::is_none") )]
	pub org_ownr_id: Option<PartyIdentification220>,
}

impl AccountOwner3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.indv_ownr_id { val.validate()? }
		if let Some(ref val) = self.org_ownr_id { val.validate()? }
		Ok(())
	}
}


// AccountOwnershipType4Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AccountOwnershipType4Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "UNCO") )]
	CodeUNCO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LIPA") )]
	CodeLIPA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ENTR") )]
	CodeENTR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CORP") )]
	CodeCORP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CUST") )]
	CodeCUST,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EURE") )]
	CodeEURE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PART") )]
	CodePART,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TRUS") )]
	CodeTRUS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GOVO") )]
	CodeGOVO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "JOIT") )]
	CodeJOIT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "COMO") )]
	CodeCOMO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "JOIN") )]
	CodeJOIN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LLCO") )]
	CodeLLCO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NOMI") )]
	CodeNOMI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NFPO") )]
	CodeNFPO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ONIS") )]
	CodeONIS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RGIC") )]
	CodeRGIC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SIGL") )]
	CodeSIGL,
}

impl AccountOwnershipType4Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AccountParties12Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountParties12Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmryOwnr", skip_serializing_if = "Option::is_none") )]
	pub pmry_ownr: Option<InvestmentAccountOwnershipInformation16>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Trstee", skip_serializing_if = "Option::is_none") )]
	pub trstee: Option<Vec<InvestmentAccountOwnershipInformation16>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nmnee", skip_serializing_if = "Option::is_none") )]
	pub nmnee: Option<InvestmentAccountOwnershipInformation16>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "JntOwnr", skip_serializing_if = "Option::is_none") )]
	pub jnt_ownr: Option<Vec<InvestmentAccountOwnershipInformation16>>,
}

impl AccountParties12Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.pmry_ownr { val.validate()? }
		if let Some(ref vec) = self.trstee { for item in vec { item.validate()? } }
		if let Some(ref val) = self.nmnee { val.validate()? }
		if let Some(ref vec) = self.jnt_ownr { for item in vec { item.validate()? } }
		Ok(())
	}
}


// AccountParties13Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountParties13Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmryOwnr", skip_serializing_if = "Option::is_none") )]
	pub pmry_ownr: Option<InvestmentAccountOwnershipInformation17>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Trstee", skip_serializing_if = "Option::is_none") )]
	pub trstee: Option<Vec<InvestmentAccountOwnershipInformation17>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nmnee", skip_serializing_if = "Option::is_none") )]
	pub nmnee: Option<InvestmentAccountOwnershipInformation17>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "JntOwnr", skip_serializing_if = "Option::is_none") )]
	pub jnt_ownr: Option<Vec<InvestmentAccountOwnershipInformation17>>,
}

impl AccountParties13Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.pmry_ownr { val.validate()? }
		if let Some(ref vec) = self.trstee { for item in vec { item.validate()? } }
		if let Some(ref val) = self.nmnee { val.validate()? }
		if let Some(ref vec) = self.jnt_ownr { for item in vec { item.validate()? } }
		Ok(())
	}
}


// AccountParties17 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountParties17 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrncplAcctPty") )]
	pub prncpl_acct_pty: AccountParties12Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ScndryOwnr", skip_serializing_if = "Option::is_none") )]
	pub scndry_ownr: Option<Vec<InvestmentAccountOwnershipInformation16>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Bnfcry", skip_serializing_if = "Option::is_none") )]
	pub bnfcry: Option<Vec<InvestmentAccountOwnershipInformation16>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PwrOfAttny", skip_serializing_if = "Option::is_none") )]
	pub pwr_of_attny: Option<Vec<InvestmentAccountOwnershipInformation16>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LglGuardn", skip_serializing_if = "Option::is_none") )]
	pub lgl_guardn: Option<Vec<InvestmentAccountOwnershipInformation16>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtdnForMnr", skip_serializing_if = "Option::is_none") )]
	pub ctdn_for_mnr: Option<Vec<InvestmentAccountOwnershipInformation16>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SucssrOnDth", skip_serializing_if = "Option::is_none") )]
	pub sucssr_on_dth: Option<Vec<InvestmentAccountOwnershipInformation16>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Admstr", skip_serializing_if = "Option::is_none") )]
	pub admstr: Option<Vec<InvestmentAccountOwnershipInformation16>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrPty", skip_serializing_if = "Option::is_none") )]
	pub othr_pty: Option<Vec<ExtendedParty14>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Grntr", skip_serializing_if = "Option::is_none") )]
	pub grntr: Option<Vec<InvestmentAccountOwnershipInformation16>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sttlr", skip_serializing_if = "Option::is_none") )]
	pub sttlr: Option<Vec<InvestmentAccountOwnershipInformation16>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SnrMggOffcl", skip_serializing_if = "Option::is_none") )]
	pub snr_mgg_offcl: Option<Vec<InvestmentAccountOwnershipInformation16>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtctr", skip_serializing_if = "Option::is_none") )]
	pub prtctr: Option<Vec<InvestmentAccountOwnershipInformation16>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegdShrhldrNm", skip_serializing_if = "Option::is_none") )]
	pub regd_shrhldr_nm: Option<RegisteredShareholderName1Choice>,
}

impl AccountParties17 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.prncpl_acct_pty.validate()?;
		if let Some(ref vec) = self.scndry_ownr { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.bnfcry { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.pwr_of_attny { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.lgl_guardn { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.ctdn_for_mnr { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.sucssr_on_dth { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.admstr { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.othr_pty { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.grntr { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.sttlr { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.snr_mgg_offcl { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.prtctr { for item in vec { item.validate()? } }
		if let Some(ref val) = self.regd_shrhldr_nm { val.validate()? }
		Ok(())
	}
}


// AccountParties18 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountParties18 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModScpIndctn") )]
	pub mod_scp_indctn: DataModification1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrncplAcctPty", skip_serializing_if = "Option::is_none") )]
	pub prncpl_acct_pty: Option<AccountParties13Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ScndryOwnr", skip_serializing_if = "Option::is_none") )]
	pub scndry_ownr: Option<Vec<InvestmentAccountOwnershipInformation17>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Bnfcry", skip_serializing_if = "Option::is_none") )]
	pub bnfcry: Option<Vec<InvestmentAccountOwnershipInformation17>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PwrOfAttny", skip_serializing_if = "Option::is_none") )]
	pub pwr_of_attny: Option<Vec<InvestmentAccountOwnershipInformation17>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LglGuardn", skip_serializing_if = "Option::is_none") )]
	pub lgl_guardn: Option<Vec<InvestmentAccountOwnershipInformation17>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtdnForMnr", skip_serializing_if = "Option::is_none") )]
	pub ctdn_for_mnr: Option<Vec<InvestmentAccountOwnershipInformation17>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SucssrOnDth", skip_serializing_if = "Option::is_none") )]
	pub sucssr_on_dth: Option<Vec<InvestmentAccountOwnershipInformation17>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Admstr", skip_serializing_if = "Option::is_none") )]
	pub admstr: Option<Vec<InvestmentAccountOwnershipInformation17>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrPty", skip_serializing_if = "Option::is_none") )]
	pub othr_pty: Option<Vec<ExtendedParty15>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Grntr", skip_serializing_if = "Option::is_none") )]
	pub grntr: Option<Vec<InvestmentAccountOwnershipInformation17>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sttlr", skip_serializing_if = "Option::is_none") )]
	pub sttlr: Option<Vec<InvestmentAccountOwnershipInformation17>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SnrMggOffcl", skip_serializing_if = "Option::is_none") )]
	pub snr_mgg_offcl: Option<Vec<InvestmentAccountOwnershipInformation17>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtctr", skip_serializing_if = "Option::is_none") )]
	pub prtctr: Option<Vec<InvestmentAccountOwnershipInformation17>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegdShrhldrNm", skip_serializing_if = "Option::is_none") )]
	pub regd_shrhldr_nm: Option<RegisteredShareholderName1Choice>,
}

impl AccountParties18 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.mod_scp_indctn.validate()?;
		if let Some(ref val) = self.prncpl_acct_pty { val.validate()? }
		if let Some(ref vec) = self.scndry_ownr { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.bnfcry { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.pwr_of_attny { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.lgl_guardn { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.ctdn_for_mnr { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.sucssr_on_dth { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.admstr { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.othr_pty { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.grntr { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.sttlr { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.snr_mgg_offcl { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.prtctr { for item in vec { item.validate()? } }
		if let Some(ref val) = self.regd_shrhldr_nm { val.validate()? }
		Ok(())
	}
}


// AccountQuery4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountQuery4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "QryTp", skip_serializing_if = "Option::is_none") )]
	pub qry_tp: Option<QueryType2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctCrit", skip_serializing_if = "Option::is_none") )]
	pub acct_crit: Option<AccountCriteria4Choice>,
}

impl AccountQuery4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.qry_tp { val.validate()? }
		if let Some(ref val) = self.acct_crit { val.validate()? }
		Ok(())
	}
}


// AccountReport33 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountReport33 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptPgntn", skip_serializing_if = "Option::is_none") )]
	pub rpt_pgntn: Option<Pagination1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ElctrncSeqNb", skip_serializing_if = "Option::is_none") )]
	pub elctrnc_seq_nb: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgSeq", skip_serializing_if = "Option::is_none") )]
	pub rptg_seq: Option<SequenceRange1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LglSeqNb", skip_serializing_if = "Option::is_none") )]
	pub lgl_seq_nb: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm", skip_serializing_if = "Option::is_none") )]
	pub cre_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrToDt", skip_serializing_if = "Option::is_none") )]
	pub fr_to_dt: Option<DateTimePeriod1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CpyDplctInd", skip_serializing_if = "Option::is_none") )]
	pub cpy_dplct_ind: Option<CopyDuplicate1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgSrc", skip_serializing_if = "Option::is_none") )]
	pub rptg_src: Option<ReportingSource1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Acct") )]
	pub acct: CashAccount43,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdAcct", skip_serializing_if = "Option::is_none") )]
	pub rltd_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Intrst", skip_serializing_if = "Option::is_none") )]
	pub intrst: Option<Vec<AccountInterest4>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Bal", skip_serializing_if = "Option::is_none") )]
	pub bal: Option<Vec<CashBalance8>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxsSummry", skip_serializing_if = "Option::is_none") )]
	pub txs_summry: Option<TotalTransactions6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ntry", skip_serializing_if = "Option::is_none") )]
	pub ntry: Option<Vec<ReportEntry14>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlRptInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_rpt_inf: Option<String>,
}

impl AccountReport33 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.rpt_pgntn { val.validate()? }
		if let Some(ref val) = self.rptg_seq { val.validate()? }
		if let Some(ref val) = self.fr_to_dt { val.validate()? }
		if let Some(ref val) = self.cpy_dplct_ind { val.validate()? }
		if let Some(ref val) = self.rptg_src { val.validate()? }
		self.acct.validate()?;
		if let Some(ref val) = self.rltd_acct { val.validate()? }
		if let Some(ref vec) = self.intrst { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.bal { for item in vec { item.validate()? } }
		if let Some(ref val) = self.txs_summry { val.validate()? }
		if let Some(ref vec) = self.ntry { for item in vec { item.validate()? } }
		if let Some(ref val) = self.addtl_rpt_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_rpt_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 500 {
				return Err(ValidationError::new(1002, "addtl_rpt_inf exceeds the maximum length of 500".to_string()));
			}
		}
		Ok(())
	}
}


// AccountReport35 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountReport35 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctId") )]
	pub acct_id: AccountIdentification4Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctOrErr") )]
	pub acct_or_err: AccountOrBusinessError6Choice,
}

impl AccountReport35 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.acct_id.validate()?;
		self.acct_or_err.validate()?;
		Ok(())
	}
}


// AccountReport36 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountReport36 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Acct") )]
	pub acct: CustomerAccount5,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UndrlygMstrAgrmt", skip_serializing_if = "Option::is_none") )]
	pub undrlyg_mstr_agrmt: Option<ContractDocument1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctDts", skip_serializing_if = "Option::is_none") )]
	pub ctrct_dts: Option<AccountContract3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mndt", skip_serializing_if = "Option::is_none") )]
	pub mndt: Option<Vec<OperationMandate7>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Grp", skip_serializing_if = "Option::is_none") )]
	pub grp: Option<Vec<Group6>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RefAcct", skip_serializing_if = "Option::is_none") )]
	pub ref_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BalTrfAcct", skip_serializing_if = "Option::is_none") )]
	pub bal_trf_acct: Option<AccountForAction1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrfAcctSvcrId", skip_serializing_if = "Option::is_none") )]
	pub trf_acct_svcr_id: Option<BranchAndFinancialInstitutionIdentification8>,
}

impl AccountReport36 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.acct.validate()?;
		if let Some(ref val) = self.undrlyg_mstr_agrmt { val.validate()? }
		if let Some(ref val) = self.ctrct_dts { val.validate()? }
		if let Some(ref vec) = self.mndt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.grp { for item in vec { item.validate()? } }
		if let Some(ref val) = self.ref_acct { val.validate()? }
		if let Some(ref val) = self.bal_trf_acct { val.validate()? }
		if let Some(ref val) = self.trf_acct_svcr_id { val.validate()? }
		Ok(())
	}
}


// AccountSchemeName1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountSchemeName1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl AccountSchemeName1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// AccountSelection3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountSelection3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctId", skip_serializing_if = "Option::is_none") )]
	pub acct_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrAcctSelctnData", skip_serializing_if = "Option::is_none") )]
	pub othr_acct_selctn_data: Option<InvestmentAccount76>,
}

impl AccountSelection3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.acct_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acct_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.othr_acct_selctn_data { val.validate()? }
		Ok(())
	}
}


// AccountStatement13 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountStatement13 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StmtPgntn", skip_serializing_if = "Option::is_none") )]
	pub stmt_pgntn: Option<Pagination1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ElctrncSeqNb", skip_serializing_if = "Option::is_none") )]
	pub elctrnc_seq_nb: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgSeq", skip_serializing_if = "Option::is_none") )]
	pub rptg_seq: Option<SequenceRange1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LglSeqNb", skip_serializing_if = "Option::is_none") )]
	pub lgl_seq_nb: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm", skip_serializing_if = "Option::is_none") )]
	pub cre_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrToDt", skip_serializing_if = "Option::is_none") )]
	pub fr_to_dt: Option<DateTimePeriod1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CpyDplctInd", skip_serializing_if = "Option::is_none") )]
	pub cpy_dplct_ind: Option<CopyDuplicate1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgSrc", skip_serializing_if = "Option::is_none") )]
	pub rptg_src: Option<ReportingSource1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Acct") )]
	pub acct: CashAccount43,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdAcct", skip_serializing_if = "Option::is_none") )]
	pub rltd_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Intrst", skip_serializing_if = "Option::is_none") )]
	pub intrst: Option<Vec<AccountInterest4>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Bal") )]
	pub bal: Vec<CashBalance8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxsSummry", skip_serializing_if = "Option::is_none") )]
	pub txs_summry: Option<TotalTransactions6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ntry", skip_serializing_if = "Option::is_none") )]
	pub ntry: Option<Vec<ReportEntry14>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlStmtInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_stmt_inf: Option<String>,
}

impl AccountStatement13 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.stmt_pgntn { val.validate()? }
		if let Some(ref val) = self.rptg_seq { val.validate()? }
		if let Some(ref val) = self.fr_to_dt { val.validate()? }
		if let Some(ref val) = self.cpy_dplct_ind { val.validate()? }
		if let Some(ref val) = self.rptg_src { val.validate()? }
		self.acct.validate()?;
		if let Some(ref val) = self.rltd_acct { val.validate()? }
		if let Some(ref vec) = self.intrst { for item in vec { item.validate()? } }
		for item in &self.bal { item.validate()? }
		if let Some(ref val) = self.txs_summry { val.validate()? }
		if let Some(ref vec) = self.ntry { for item in vec { item.validate()? } }
		if let Some(ref val) = self.addtl_stmt_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_stmt_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 500 {
				return Err(ValidationError::new(1002, "addtl_stmt_inf exceeds the maximum length of 500".to_string()));
			}
		}
		Ok(())
	}
}


// AccountStatus2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountStatus2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nbld", skip_serializing_if = "Option::is_none") )]
	pub nbld: Option<EnabledStatusReason1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dsbld", skip_serializing_if = "Option::is_none") )]
	pub dsbld: Option<DisabledStatusReason1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pdg", skip_serializing_if = "Option::is_none") )]
	pub pdg: Option<PendingStatusReason1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PdgOpng", skip_serializing_if = "Option::is_none") )]
	pub pdg_opng: Option<PendingOpeningStatusReason1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Profrm", skip_serializing_if = "Option::is_none") )]
	pub profrm: Option<ProformaStatusReason1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Clsd", skip_serializing_if = "Option::is_none") )]
	pub clsd: Option<ClosedStatusReason1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClsrPdg", skip_serializing_if = "Option::is_none") )]
	pub clsr_pdg: Option<ClosurePendingStatusReason1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<Vec<OtherAccountStatus1>>,
}

impl AccountStatus2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nbld { val.validate()? }
		if let Some(ref val) = self.dsbld { val.validate()? }
		if let Some(ref val) = self.pdg { val.validate()? }
		if let Some(ref val) = self.pdg_opng { val.validate()? }
		if let Some(ref val) = self.profrm { val.validate()? }
		if let Some(ref val) = self.clsd { val.validate()? }
		if let Some(ref val) = self.clsr_pdg { val.validate()? }
		if let Some(ref vec) = self.othr { for item in vec { item.validate()? } }
		Ok(())
	}
}


// AccountStatus3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AccountStatus3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ENAB") )]
	CodeENAB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DISA") )]
	CodeDISA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DELE") )]
	CodeDELE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FORM") )]
	CodeFORM,
}

impl AccountStatus3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AccountStatusModification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountStatusModification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModCd", skip_serializing_if = "Option::is_none") )]
	pub mod_cd: Option<Modification1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts") )]
	pub sts: AccountStatus3Code,
}

impl AccountStatusModification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mod_cd { val.validate()? }
		self.sts.validate()?;
		Ok(())
	}
}


// AccountStatusUpdateInstruction1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountStatusUpdateInstruction1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "UpdInstr") )]
	pub upd_instr: AccountStatusUpdateInstruction1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UpdInstrRsn", skip_serializing_if = "Option::is_none") )]
	pub upd_instr_rsn: Option<AccountStatusUpdateInstructionReason1Choice>,
}

impl AccountStatusUpdateInstruction1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.upd_instr.validate()?;
		if let Some(ref val) = self.upd_instr_rsn { val.validate()? }
		Ok(())
	}
}


// AccountStatusUpdateInstruction1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountStatusUpdateInstruction1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<AccountStatusUpdateInstruction1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification36>,
}

impl AccountStatusUpdateInstruction1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// AccountStatusUpdateInstruction1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AccountStatusUpdateInstruction1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CLOS") )]
	CodeCLOS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REAC") )]
	CodeREAC,
}

impl AccountStatusUpdateInstruction1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AccountStatusUpdateInstructionReason1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountStatusUpdateInstructionReason1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<AccountStatusUpdateInstructionReason2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
}

impl AccountStatusUpdateInstructionReason1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 350".to_string()));
			}
		}
		Ok(())
	}
}


// AccountStatusUpdateInstructionReason1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountStatusUpdateInstructionReason1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NoSpcfdRsn", skip_serializing_if = "Option::is_none") )]
	pub no_spcfd_rsn: Option<NoReasonCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<Vec<AccountStatusUpdateInstructionReason1>>,
}

impl AccountStatusUpdateInstructionReason1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.no_spcfd_rsn { val.validate()? }
		if let Some(ref vec) = self.rsn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// AccountStatusUpdateInstructionReason2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountStatusUpdateInstructionReason2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<AccountStatusUpdateRequestReason1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification36>,
}

impl AccountStatusUpdateInstructionReason2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// AccountStatusUpdateRequestReason1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AccountStatusUpdateRequestReason1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CLOE") )]
	CodeCLOE,
}

impl AccountStatusUpdateRequestReason1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AccountSwitchDetails1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountSwitchDetails1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnqRefNb") )]
	pub unq_ref_nb: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RtgUnqRefNb") )]
	pub rtg_unq_ref_nb: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SwtchRcvdDtTm", skip_serializing_if = "Option::is_none") )]
	pub swtch_rcvd_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SwtchDt", skip_serializing_if = "Option::is_none") )]
	pub swtch_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SwtchTp") )]
	pub swtch_tp: SwitchType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SwtchSts", skip_serializing_if = "Option::is_none") )]
	pub swtch_sts: Option<SwitchStatus1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BalTrfWndw", skip_serializing_if = "Option::is_none") )]
	pub bal_trf_wndw: Option<BalanceTransferWindow1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rspn", skip_serializing_if = "Option::is_none") )]
	pub rspn: Option<Vec<ResponseDetails1>>,
}

impl AccountSwitchDetails1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.unq_ref_nb.chars().count() < 1 {
			return Err(ValidationError::new(1001, "unq_ref_nb is shorter than the minimum length of 1".to_string()));
		}
		if self.unq_ref_nb.chars().count() > 35 {
			return Err(ValidationError::new(1002, "unq_ref_nb exceeds the maximum length of 35".to_string()));
		}
		if self.rtg_unq_ref_nb.chars().count() < 1 {
			return Err(ValidationError::new(1001, "rtg_unq_ref_nb is shorter than the minimum length of 1".to_string()));
		}
		if self.rtg_unq_ref_nb.chars().count() > 35 {
			return Err(ValidationError::new(1002, "rtg_unq_ref_nb exceeds the maximum length of 35".to_string()));
		}
		self.swtch_tp.validate()?;
		if let Some(ref val) = self.swtch_sts { val.validate()? }
		if let Some(ref val) = self.bal_trf_wndw { val.validate()? }
		if let Some(ref vec) = self.rspn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// AccountTax1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountTax1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClctnMtd") )]
	pub clctn_mtd: BillingTaxCalculationMethod1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rgn", skip_serializing_if = "Option::is_none") )]
	pub rgn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NonResCtry", skip_serializing_if = "Option::is_none") )]
	pub non_res_ctry: Option<ResidenceLocation1Choice>,
}

impl AccountTax1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.clctn_mtd.validate()?;
		if let Some(ref val) = self.rgn {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rgn is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 40 {
				return Err(ValidationError::new(1002, "rgn exceeds the maximum length of 40".to_string()));
			}
		}
		if let Some(ref val) = self.non_res_ctry { val.validate()? }
		Ok(())
	}
}


// AccountType2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountType2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<FundCashAccount4Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl AccountType2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// AccountUsageType2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountUsageType2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<AccountUsageType2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl AccountUsageType2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// AccountUsageType2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AccountUsageType2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "INVE") )]
	CodeINVE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISSP") )]
	CodeISSP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SETP") )]
	CodeSETP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TRDP") )]
	CodeTRDP,
}

impl AccountUsageType2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AccountingStatus1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AccountingStatus1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<AccountingStatus1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl AccountingStatus1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// AccountingStatus1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AccountingStatus1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "YDOM") )]
	CodeYDOM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NDOM") )]
	CodeNDOM,
}

impl AccountingStatus1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AcknowledgedAcceptedStatus21Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AcknowledgedAcceptedStatus21Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NoSpcfdRsn", skip_serializing_if = "Option::is_none") )]
	pub no_spcfd_rsn: Option<NoReasonCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<Vec<AcknowledgementReason9>>,
}

impl AcknowledgedAcceptedStatus21Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.no_spcfd_rsn { val.validate()? }
		if let Some(ref vec) = self.rsn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// AcknowledgedAcceptedStatus24Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AcknowledgedAcceptedStatus24Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NoSpcfdRsn", skip_serializing_if = "Option::is_none") )]
	pub no_spcfd_rsn: Option<NoReasonCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<Vec<AcknowledgementReason12>>,
}

impl AcknowledgedAcceptedStatus24Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.no_spcfd_rsn { val.validate()? }
		if let Some(ref vec) = self.rsn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// AcknowledgementDetails1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AcknowledgementDetails1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PayInSchdlRef", skip_serializing_if = "Option::is_none") )]
	pub pay_in_schdl_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PayInCallRef", skip_serializing_if = "Option::is_none") )]
	pub pay_in_call_ref: Option<String>,
}

impl AcknowledgementDetails1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.pay_in_schdl_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pay_in_schdl_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "pay_in_schdl_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.pay_in_call_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pay_in_call_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "pay_in_call_ref exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// AcknowledgementReason12 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AcknowledgementReason12 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd") )]
	pub cd: AcknowledgementReason15Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlRsnInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_rsn_inf: Option<String>,
}

impl AcknowledgementReason12 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.cd.validate()?;
		if let Some(ref val) = self.addtl_rsn_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_rsn_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 210 {
				return Err(ValidationError::new(1002, "addtl_rsn_inf exceeds the maximum length of 210".to_string()));
			}
		}
		Ok(())
	}
}


// AcknowledgementReason12Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AcknowledgementReason12Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<AcknowledgementReason5Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl AcknowledgementReason12Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// AcknowledgementReason15Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AcknowledgementReason15Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<AcknowledgementReason3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl AcknowledgementReason15Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// AcknowledgementReason3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AcknowledgementReason3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ADEA") )]
	CodeADEA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SMPG") )]
	CodeSMPG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
}

impl AcknowledgementReason3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AcknowledgementReason5Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AcknowledgementReason5Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ADEA") )]
	CodeADEA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SMPG") )]
	CodeSMPG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CDCY") )]
	CodeCDCY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CDRG") )]
	CodeCDRG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CDRE") )]
	CodeCDRE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NSTP") )]
	CodeNSTP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RQWV") )]
	CodeRQWV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LATE") )]
	CodeLATE,
}

impl AcknowledgementReason5Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AcknowledgementReason9 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AcknowledgementReason9 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd") )]
	pub cd: AcknowledgementReason12Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlRsnInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_rsn_inf: Option<String>,
}

impl AcknowledgementReason9 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.cd.validate()?;
		if let Some(ref val) = self.addtl_rsn_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_rsn_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 210 {
				return Err(ValidationError::new(1002, "addtl_rsn_inf exceeds the maximum length of 210".to_string()));
			}
		}
		Ok(())
	}
}


// ActivationHeader3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ActivationHeader3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm") )]
	pub cre_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgOrgtr", skip_serializing_if = "Option::is_none") )]
	pub msg_orgtr: Option<RTPPartyIdentification2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgRcpt", skip_serializing_if = "Option::is_none") )]
	pub msg_rcpt: Option<RTPPartyIdentification2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitgPty") )]
	pub initg_pty: RTPPartyIdentification2,
}

impl ActivationHeader3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.msg_orgtr { val.validate()? }
		if let Some(ref val) = self.msg_rcpt { val.validate()? }
		self.initg_pty.validate()?;
		Ok(())
	}
}


// ActivationStatus3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ActivationStatus3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlBizInstr", skip_serializing_if = "Option::is_none") )]
	pub orgnl_biz_instr: Option<OriginalBusinessInstruction1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts") )]
	pub sts: ServiceStatus1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsRsn", skip_serializing_if = "Option::is_none") )]
	pub sts_rsn: Option<DebtorActivationStatusReason3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlActvtnRef", skip_serializing_if = "Option::is_none") )]
	pub orgnl_actvtn_ref: Option<OriginalActivation3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FctvActvtnDt", skip_serializing_if = "Option::is_none") )]
	pub fctv_actvtn_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl ActivationStatus3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgnl_biz_instr { val.validate()? }
		self.sts.validate()?;
		if let Some(ref val) = self.sts_rsn { val.validate()? }
		if let Some(ref val) = self.orgnl_actvtn_ref { val.validate()? }
		if let Some(ref val) = self.fctv_actvtn_dt { val.validate()? }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// ActiveAmountRange3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ActiveAmountRange3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ImpldCcyAndAmtRg", skip_serializing_if = "Option::is_none") )]
	pub impld_ccy_and_amt_rg: Option<ImpliedCurrencyAndAmountRange1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CcyAndAmtRg", skip_serializing_if = "Option::is_none") )]
	pub ccy_and_amt_rg: Option<ActiveCurrencyAndAmountRange3>,
}

impl ActiveAmountRange3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.impld_ccy_and_amt_rg { val.validate()? }
		if let Some(ref val) = self.ccy_and_amt_rg { val.validate()? }
		Ok(())
	}
}


// ActiveCurrencyAnd13DecimalAmount ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ActiveCurrencyAnd13DecimalAmount {
	#[cfg_attr( feature = "derive_serde", serde(rename = "@Ccy") )]
	pub ccy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "$value") )]
	pub value: f64,
}

impl ActiveCurrencyAnd13DecimalAmount {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ActiveCurrencyAnd24Amount ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ActiveCurrencyAnd24Amount {
	#[cfg_attr( feature = "derive_serde", serde(rename = "@Ccy") )]
	pub ccy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "$value") )]
	pub value: f64,
}

impl ActiveCurrencyAnd24Amount {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ActiveCurrencyAndAmount ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ActiveCurrencyAndAmount {
	#[cfg_attr( feature = "derive_serde", serde(rename = "@Ccy") )]
	pub ccy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "$value") )]
	pub value: f64,
}

impl ActiveCurrencyAndAmount {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ActiveCurrencyAndAmountRange3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ActiveCurrencyAndAmountRange3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ImpliedCurrencyAmountRange1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbtInd", skip_serializing_if = "Option::is_none") )]
	pub cdt_dbt_ind: Option<CreditDebitCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ccy") )]
	pub ccy: String,
}

impl ActiveCurrencyAndAmountRange3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.amt.validate()?;
		if let Some(ref val) = self.cdt_dbt_ind { val.validate()? }
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.ccy) {
			return Err(ValidationError::new(1005, "ccy does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// ActiveOrHistoricAmountRange2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ActiveOrHistoricAmountRange2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ImpldCcyAndAmtRg", skip_serializing_if = "Option::is_none") )]
	pub impld_ccy_and_amt_rg: Option<ImpliedCurrencyAndAmountRange1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CcyAndAmtRg", skip_serializing_if = "Option::is_none") )]
	pub ccy_and_amt_rg: Option<ActiveOrHistoricCurrencyAndAmountRange2>,
}

impl ActiveOrHistoricAmountRange2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.impld_ccy_and_amt_rg { val.validate()? }
		if let Some(ref val) = self.ccy_and_amt_rg { val.validate()? }
		Ok(())
	}
}


// ActiveOrHistoricCurrencyAnd13DecimalAmount ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ActiveOrHistoricCurrencyAnd13DecimalAmount {
	#[cfg_attr( feature = "derive_serde", serde(rename = "@Ccy") )]
	pub ccy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "$value") )]
	pub value: f64,
}

impl ActiveOrHistoricCurrencyAnd13DecimalAmount {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ActiveOrHistoricCurrencyAnd19DecimalAmount ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ActiveOrHistoricCurrencyAnd19DecimalAmount {
	#[cfg_attr( feature = "derive_serde", serde(rename = "@Ccy") )]
	pub ccy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "$value") )]
	pub value: f64,
}

impl ActiveOrHistoricCurrencyAnd19DecimalAmount {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ActiveOrHistoricCurrencyAnd20DecimalAmount ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ActiveOrHistoricCurrencyAnd20DecimalAmount {
	#[cfg_attr( feature = "derive_serde", serde(rename = "@Ccy") )]
	pub ccy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "$value") )]
	pub value: f64,
}

impl ActiveOrHistoricCurrencyAnd20DecimalAmount {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ActiveOrHistoricCurrencyAndAmount ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ActiveOrHistoricCurrencyAndAmount {
	#[cfg_attr( feature = "derive_serde", serde(rename = "@Ccy") )]
	pub ccy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "$value") )]
	pub value: f64,
}

impl ActiveOrHistoricCurrencyAndAmount {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ActiveOrHistoricCurrencyAndAmountRange2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ActiveOrHistoricCurrencyAndAmountRange2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ImpliedCurrencyAmountRange1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbtInd", skip_serializing_if = "Option::is_none") )]
	pub cdt_dbt_ind: Option<CreditDebitCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ccy") )]
	pub ccy: String,
}

impl ActiveOrHistoricCurrencyAndAmountRange2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.amt.validate()?;
		if let Some(ref val) = self.cdt_dbt_ind { val.validate()? }
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.ccy) {
			return Err(ValidationError::new(1005, "ccy does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// AdditionalInformation1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AdditionalInformation1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "InfTp") )]
	pub inf_tp: InformationType1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InfVal") )]
	pub inf_val: String,
}

impl AdditionalInformation1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.inf_tp.validate()?;
		if self.inf_val.chars().count() < 1 {
			return Err(ValidationError::new(1001, "inf_val is shorter than the minimum length of 1".to_string()));
		}
		if self.inf_val.chars().count() > 350 {
			return Err(ValidationError::new(1002, "inf_val exceeds the maximum length of 350".to_string()));
		}
		Ok(())
	}
}


// AdditionalInformation15 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AdditionalInformation15 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "InfTp") )]
	pub inf_tp: GenericIdentification36,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InfVal") )]
	pub inf_val: String,
}

impl AdditionalInformation15 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.inf_tp.validate()?;
		if self.inf_val.chars().count() < 1 {
			return Err(ValidationError::new(1001, "inf_val is shorter than the minimum length of 1".to_string()));
		}
		if self.inf_val.chars().count() > 350 {
			return Err(ValidationError::new(1002, "inf_val exceeds the maximum length of 350".to_string()));
		}
		Ok(())
	}
}


// AdditionalInformation5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AdditionalInformation5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Inf") )]
	pub inf: Vec<String>,
}

impl AdditionalInformation5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		for item in &self.inf {
			if item.chars().count() < 1 {
				return Err(ValidationError::new(1001, "inf is shorter than the minimum length of 1".to_string()));
			}
			if item.chars().count() > 256 {
				return Err(ValidationError::new(1002, "inf exceeds the maximum length of 256".to_string()));
			}
		}
		Ok(())
	}
}


// AdditionalParameters1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AdditionalParameters1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctry", skip_serializing_if = "Option::is_none") )]
	pub ctry: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ccy", skip_serializing_if = "Option::is_none") )]
	pub ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GeoArea", skip_serializing_if = "Option::is_none") )]
	pub geo_area: Option<String>,
}

impl AdditionalParameters1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ctry {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.geo_area {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "geo_area is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "geo_area exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// AdditionalParameters16 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AdditionalParameters16 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtlSttlm", skip_serializing_if = "Option::is_none") )]
	pub prtl_sttlm: Option<PartialSettlement2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsPrtlConfId", skip_serializing_if = "Option::is_none") )]
	pub prvs_prtl_conf_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctOwnrTxId", skip_serializing_if = "Option::is_none") )]
	pub acct_ownr_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcrTxId", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PoolId", skip_serializing_if = "Option::is_none") )]
	pub pool_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CorpActnEvtId", skip_serializing_if = "Option::is_none") )]
	pub corp_actn_evt_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktInfrstrctrTxId", skip_serializing_if = "Option::is_none") )]
	pub mkt_infrstrctr_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrcrTxId", skip_serializing_if = "Option::is_none") )]
	pub prcr_tx_id: Option<String>,
}

impl AdditionalParameters16 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.prtl_sttlm { val.validate()? }
		if let Some(ref val) = self.prvs_prtl_conf_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prvs_prtl_conf_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prvs_prtl_conf_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.acct_ownr_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_ownr_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acct_ownr_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.acct_svcr_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_svcr_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acct_svcr_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.pool_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pool_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "pool_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.corp_actn_evt_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "corp_actn_evt_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "corp_actn_evt_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.mkt_infrstrctr_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mkt_infrstrctr_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "mkt_infrstrctr_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.prcr_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prcr_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prcr_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// AdditionalProductInformation3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AdditionalProductInformation3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmTxCostsExAnteUK", skip_serializing_if = "Option::is_none") )]
	pub fin_instrm_tx_costs_ex_ante_uk: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmTxCostsExPstUK", skip_serializing_if = "Option::is_none") )]
	pub fin_instrm_tx_costs_ex_pst_uk: Option<f64>,
}

impl AdditionalProductInformation3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AdditionalReference10 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AdditionalReference10 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ref") )]
	pub ref_attr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RefIssr", skip_serializing_if = "Option::is_none") )]
	pub ref_issr: Option<PartyIdentification139>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgNm", skip_serializing_if = "Option::is_none") )]
	pub msg_nm: Option<String>,
}

impl AdditionalReference10 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.ref_attr.chars().count() < 1 {
			return Err(ValidationError::new(1001, "ref_attr is shorter than the minimum length of 1".to_string()));
		}
		if self.ref_attr.chars().count() > 35 {
			return Err(ValidationError::new(1002, "ref_attr exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.ref_issr { val.validate()? }
		if let Some(ref val) = self.msg_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "msg_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "msg_nm exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// AdditionalReference13 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AdditionalReference13 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ref") )]
	pub ref_attr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RefIssr", skip_serializing_if = "Option::is_none") )]
	pub ref_issr: Option<PartyIdentification125Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgNm", skip_serializing_if = "Option::is_none") )]
	pub msg_nm: Option<String>,
}

impl AdditionalReference13 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.ref_attr.chars().count() < 1 {
			return Err(ValidationError::new(1001, "ref_attr is shorter than the minimum length of 1".to_string()));
		}
		if self.ref_attr.chars().count() > 35 {
			return Err(ValidationError::new(1002, "ref_attr exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.ref_issr { val.validate()? }
		if let Some(ref val) = self.msg_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "msg_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "msg_nm exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// AdditionalReference3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AdditionalReference3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ref") )]
	pub ref_attr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RefIssr", skip_serializing_if = "Option::is_none") )]
	pub ref_issr: Option<PartyIdentification2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgNm", skip_serializing_if = "Option::is_none") )]
	pub msg_nm: Option<String>,
}

impl AdditionalReference3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.ref_attr.chars().count() < 1 {
			return Err(ValidationError::new(1001, "ref_attr is shorter than the minimum length of 1".to_string()));
		}
		if self.ref_attr.chars().count() > 35 {
			return Err(ValidationError::new(1002, "ref_attr exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.ref_issr { val.validate()? }
		if let Some(ref val) = self.msg_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "msg_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "msg_nm exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// AdditionalRequestData1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AdditionalRequestData1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdDbtAuthstn", skip_serializing_if = "Option::is_none") )]
	pub reqd_dbt_authstn: Option<DebitAuthorisation3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdCompstn", skip_serializing_if = "Option::is_none") )]
	pub reqd_compstn: Option<CompensationRequest1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdValtn", skip_serializing_if = "Option::is_none") )]
	pub reqd_valtn: Option<AdjustmentRequest1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqNrrtv", skip_serializing_if = "Option::is_none") )]
	pub req_nrrtv: Option<String>,
}

impl AdditionalRequestData1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.reqd_dbt_authstn { val.validate()? }
		if let Some(ref val) = self.reqd_compstn { val.validate()? }
		if let Some(ref val) = self.reqd_valtn { val.validate()? }
		if let Some(ref val) = self.req_nrrtv {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "req_nrrtv is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 500 {
				return Err(ValidationError::new(1002, "req_nrrtv exceeds the maximum length of 500".to_string()));
			}
		}
		Ok(())
	}
}


// AdditiononalInformation13 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AdditiononalInformation13 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Lmttn", skip_serializing_if = "Option::is_none") )]
	pub lmttn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctVldtn", skip_serializing_if = "Option::is_none") )]
	pub acct_vldtn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rgltr", skip_serializing_if = "Option::is_none") )]
	pub rgltr: Option<PartyIdentification125Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts", skip_serializing_if = "Option::is_none") )]
	pub sts: Option<RestrictionStatus1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prd", skip_serializing_if = "Option::is_none") )]
	pub prd: Option<DateTimePeriod2>,
}

impl AdditiononalInformation13 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.lmttn {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "lmttn is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "lmttn exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.acct_vldtn {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_vldtn is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "acct_vldtn exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tp exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.rgltr { val.validate()? }
		if let Some(ref val) = self.sts { val.validate()? }
		if let Some(ref val) = self.prd { val.validate()? }
		Ok(())
	}
}


// AddressModification3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AddressModification3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModCd", skip_serializing_if = "Option::is_none") )]
	pub mod_cd: Option<Modification1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Adr") )]
	pub adr: PostalAddress27,
}

impl AddressModification3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mod_cd { val.validate()? }
		self.adr.validate()?;
		Ok(())
	}
}


// AddressType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AddressType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<AddressType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl AddressType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// AddressType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AddressType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "HOME") )]
	CodeHOME,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BIZZ") )]
	CodeBIZZ,
}

impl AddressType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AddressType2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AddressType2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<AddressType2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl AddressType2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// AddressType2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AddressType2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ADDR") )]
	CodeADDR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PBOX") )]
	CodePBOX,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HOME") )]
	CodeHOME,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BIZZ") )]
	CodeBIZZ,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MLTO") )]
	CodeMLTO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DLVY") )]
	CodeDLVY,
}

impl AddressType2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AddressType3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AddressType3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<AddressType2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl AddressType3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// AdjustmentCompensation1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AdjustmentCompensation1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitlAmt", skip_serializing_if = "Option::is_none") )]
	pub initl_amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DueChrgs", skip_serializing_if = "Option::is_none") )]
	pub due_chrgs: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AmtDue") )]
	pub amt_due: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CompstnAgt", skip_serializing_if = "Option::is_none") )]
	pub compstn_agt: Option<BranchAndFinancialInstitutionIdentification6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CompstnAcct", skip_serializing_if = "Option::is_none") )]
	pub compstn_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prd", skip_serializing_if = "Option::is_none") )]
	pub prd: Option<DatePeriod5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstRate", skip_serializing_if = "Option::is_none") )]
	pub intrst_rate: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<String>,
}

impl AdjustmentCompensation1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.initl_amt { val.validate()? }
		if let Some(ref val) = self.due_chrgs { val.validate()? }
		self.amt_due.validate()?;
		if let Some(ref val) = self.compstn_agt { val.validate()? }
		if let Some(ref val) = self.compstn_acct { val.validate()? }
		if let Some(ref val) = self.prd { val.validate()? }
		if let Some(ref val) = self.rsn {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rsn is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "rsn exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// AdjustmentRequest1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AdjustmentRequest1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prd", skip_serializing_if = "Option::is_none") )]
	pub prd: Option<DatePeriod5>,
}

impl AdjustmentRequest1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.prd { val.validate()? }
		Ok(())
	}
}


// AdviceType1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AdviceType1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtAdvc", skip_serializing_if = "Option::is_none") )]
	pub cdt_advc: Option<AdviceType1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtAdvc", skip_serializing_if = "Option::is_none") )]
	pub dbt_advc: Option<AdviceType1Choice>,
}

impl AdviceType1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cdt_advc { val.validate()? }
		if let Some(ref val) = self.dbt_advc { val.validate()? }
		Ok(())
	}
}


// AdviceType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AdviceType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<AdviceType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl AdviceType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// AdviceType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AdviceType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ADWD") )]
	CodeADWD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ADND") )]
	CodeADND,
}

impl AdviceType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AgreedRate2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AgreedRate2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "XchgRate") )]
	pub xchg_rate: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnitCcy") )]
	pub unit_ccy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QtdCcy") )]
	pub qtd_ccy: String,
}

impl AgreedRate2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.unit_ccy) {
			return Err(ValidationError::new(1005, "unit_ccy does not match the required pattern".to_string()));
		}
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.qtd_ccy) {
			return Err(ValidationError::new(1005, "qtd_ccy does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// AgreementType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AgreementType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl AgreementType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "tp exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// AgreementType2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AgreementType2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl AgreementType2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "tp exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 50 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 50".to_string()));
			}
		}
		Ok(())
	}
}


// AgriculturalCommodityDairy1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AgriculturalCommodityDairy1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType20Code,
}

impl AgriculturalCommodityDairy1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		Ok(())
	}
}


// AgriculturalCommodityDairy2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AgriculturalCommodityDairy2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType20Code>,
}

impl AgriculturalCommodityDairy2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// AgriculturalCommodityForestry1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AgriculturalCommodityForestry1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType21Code,
}

impl AgriculturalCommodityForestry1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		Ok(())
	}
}


// AgriculturalCommodityForestry2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AgriculturalCommodityForestry2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType21Code>,
}

impl AgriculturalCommodityForestry2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// AgriculturalCommodityGrain1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AgriculturalCommodityGrain1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType5Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlSubPdct", skip_serializing_if = "Option::is_none") )]
	pub addtl_sub_pdct: Option<AssetClassDetailedSubProductType15Code>,
}

impl AgriculturalCommodityGrain1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		if let Some(ref val) = self.addtl_sub_pdct { val.validate()? }
		Ok(())
	}
}


// AgriculturalCommodityGrain2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AgriculturalCommodityGrain2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType5Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlSubPdct") )]
	pub addtl_sub_pdct: AssetClassDetailedSubProductType30Code,
}

impl AgriculturalCommodityGrain2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		self.addtl_sub_pdct.validate()?;
		Ok(())
	}
}


// AgriculturalCommodityGrain3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AgriculturalCommodityGrain3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType5Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlSubPdct", skip_serializing_if = "Option::is_none") )]
	pub addtl_sub_pdct: Option<AssetClassDetailedSubProductType30Code>,
}

impl AgriculturalCommodityGrain3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		if let Some(ref val) = self.addtl_sub_pdct { val.validate()? }
		Ok(())
	}
}


// AgriculturalCommodityLiveStock1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AgriculturalCommodityLiveStock1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType22Code,
}

impl AgriculturalCommodityLiveStock1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		Ok(())
	}
}


// AgriculturalCommodityLiveStock2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AgriculturalCommodityLiveStock2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType22Code>,
}

impl AgriculturalCommodityLiveStock2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// AgriculturalCommodityOilSeed1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AgriculturalCommodityOilSeed1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlSubPdct") )]
	pub addtl_sub_pdct: AssetClassDetailedSubProductType1Code,
}

impl AgriculturalCommodityOilSeed1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		self.addtl_sub_pdct.validate()?;
		Ok(())
	}
}


// AgriculturalCommodityOilSeed2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AgriculturalCommodityOilSeed2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlSubPdct", skip_serializing_if = "Option::is_none") )]
	pub addtl_sub_pdct: Option<AssetClassDetailedSubProductType1Code>,
}

impl AgriculturalCommodityOilSeed2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		if let Some(ref val) = self.addtl_sub_pdct { val.validate()? }
		Ok(())
	}
}


// AgriculturalCommodityOliveOil1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AgriculturalCommodityOliveOil1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType3Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlSubPdct", skip_serializing_if = "Option::is_none") )]
	pub addtl_sub_pdct: Option<AssetClassDetailedSubProductType4Code>,
}

impl AgriculturalCommodityOliveOil1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		if let Some(ref val) = self.addtl_sub_pdct { val.validate()? }
		Ok(())
	}
}


// AgriculturalCommodityOliveOil2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AgriculturalCommodityOliveOil2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType3Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlSubPdct") )]
	pub addtl_sub_pdct: AssetClassDetailedSubProductType29Code,
}

impl AgriculturalCommodityOliveOil2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		self.addtl_sub_pdct.validate()?;
		Ok(())
	}
}


// AgriculturalCommodityOliveOil3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AgriculturalCommodityOliveOil3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlSubPdct", skip_serializing_if = "Option::is_none") )]
	pub addtl_sub_pdct: Option<AssetClassDetailedSubProductType29Code>,
}

impl AgriculturalCommodityOliveOil3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		if let Some(ref val) = self.addtl_sub_pdct { val.validate()? }
		Ok(())
	}
}


// AgriculturalCommodityOther1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AgriculturalCommodityOther1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType49Code,
}

impl AgriculturalCommodityOther1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		Ok(())
	}
}


// AgriculturalCommodityOther2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AgriculturalCommodityOther2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType49Code>,
}

impl AgriculturalCommodityOther2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// AgriculturalCommodityPotato1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AgriculturalCommodityPotato1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType45Code,
}

impl AgriculturalCommodityPotato1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		Ok(())
	}
}


// AgriculturalCommodityPotato2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AgriculturalCommodityPotato2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType45Code>,
}

impl AgriculturalCommodityPotato2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// AgriculturalCommoditySeafood1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AgriculturalCommoditySeafood1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType23Code,
}

impl AgriculturalCommoditySeafood1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		Ok(())
	}
}


// AgriculturalCommoditySeafood2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AgriculturalCommoditySeafood2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType23Code>,
}

impl AgriculturalCommoditySeafood2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// AgriculturalCommoditySoft1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AgriculturalCommoditySoft1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlSubPdct") )]
	pub addtl_sub_pdct: AssetClassDetailedSubProductType2Code,
}

impl AgriculturalCommoditySoft1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		self.addtl_sub_pdct.validate()?;
		Ok(())
	}
}


// AgriculturalCommoditySoft2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AgriculturalCommoditySoft2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlSubPdct", skip_serializing_if = "Option::is_none") )]
	pub addtl_sub_pdct: Option<AssetClassDetailedSubProductType2Code>,
}

impl AgriculturalCommoditySoft2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		if let Some(ref val) = self.addtl_sub_pdct { val.validate()? }
		Ok(())
	}
}


// AllocationIndicator1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AllocationIndicator1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "POST") )]
	CodePOST,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PREA") )]
	CodePREA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UNAL") )]
	CodeUNAL,
}

impl AllocationIndicator1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AlternateSecurityIdentification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AlternateSecurityIdentification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DmstIdSrc", skip_serializing_if = "Option::is_none") )]
	pub dmst_id_src: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtryIdSrc", skip_serializing_if = "Option::is_none") )]
	pub prtry_id_src: Option<String>,
}

impl AlternateSecurityIdentification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.dmst_id_src {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "dmst_id_src does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.prtry_id_src {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry_id_src is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry_id_src exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// AlternateSecurityIdentification7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AlternateSecurityIdentification7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IdSrc") )]
	pub id_src: IdentificationSource1Choice,
}

impl AlternateSecurityIdentification7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		self.id_src.validate()?;
		Ok(())
	}
}


// AmendmentInformationDetails14 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AmendmentInformationDetails14 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMndtId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_mndt_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlCdtrSchmeId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_cdtr_schme_id: Option<PartyIdentification135>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlCdtrAgt", skip_serializing_if = "Option::is_none") )]
	pub orgnl_cdtr_agt: Option<BranchAndFinancialInstitutionIdentification6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlCdtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub orgnl_cdtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlDbtr", skip_serializing_if = "Option::is_none") )]
	pub orgnl_dbtr: Option<PartyIdentification135>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlDbtrAcct", skip_serializing_if = "Option::is_none") )]
	pub orgnl_dbtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlDbtrAgt", skip_serializing_if = "Option::is_none") )]
	pub orgnl_dbtr_agt: Option<BranchAndFinancialInstitutionIdentification6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlDbtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub orgnl_dbtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlFnlColltnDt", skip_serializing_if = "Option::is_none") )]
	pub orgnl_fnl_colltn_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlFrqcy", skip_serializing_if = "Option::is_none") )]
	pub orgnl_frqcy: Option<Frequency36Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlRsn", skip_serializing_if = "Option::is_none") )]
	pub orgnl_rsn: Option<MandateSetupReason1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlTrckgDays", skip_serializing_if = "Option::is_none") )]
	pub orgnl_trckg_days: Option<String>,
}

impl AmendmentInformationDetails14 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgnl_mndt_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_mndt_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_mndt_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_cdtr_schme_id { val.validate()? }
		if let Some(ref val) = self.orgnl_cdtr_agt { val.validate()? }
		if let Some(ref val) = self.orgnl_cdtr_agt_acct { val.validate()? }
		if let Some(ref val) = self.orgnl_dbtr { val.validate()? }
		if let Some(ref val) = self.orgnl_dbtr_acct { val.validate()? }
		if let Some(ref val) = self.orgnl_dbtr_agt { val.validate()? }
		if let Some(ref val) = self.orgnl_dbtr_agt_acct { val.validate()? }
		if let Some(ref val) = self.orgnl_frqcy { val.validate()? }
		if let Some(ref val) = self.orgnl_rsn { val.validate()? }
		if let Some(ref val) = self.orgnl_trckg_days {
			let pattern = Regex::new("[0-9]{2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "orgnl_trckg_days does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// AmendmentInformationDetails15 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AmendmentInformationDetails15 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMndtId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_mndt_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlCdtrSchmeId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_cdtr_schme_id: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlCdtrAgt", skip_serializing_if = "Option::is_none") )]
	pub orgnl_cdtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlCdtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub orgnl_cdtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlDbtr", skip_serializing_if = "Option::is_none") )]
	pub orgnl_dbtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlDbtrAcct", skip_serializing_if = "Option::is_none") )]
	pub orgnl_dbtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlDbtrAgt", skip_serializing_if = "Option::is_none") )]
	pub orgnl_dbtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlDbtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub orgnl_dbtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlFnlColltnDt", skip_serializing_if = "Option::is_none") )]
	pub orgnl_fnl_colltn_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlFrqcy", skip_serializing_if = "Option::is_none") )]
	pub orgnl_frqcy: Option<Frequency36Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlRsn", skip_serializing_if = "Option::is_none") )]
	pub orgnl_rsn: Option<MandateSetupReason1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlTrckgDays", skip_serializing_if = "Option::is_none") )]
	pub orgnl_trckg_days: Option<String>,
}

impl AmendmentInformationDetails15 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgnl_mndt_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_mndt_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_mndt_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_cdtr_schme_id { val.validate()? }
		if let Some(ref val) = self.orgnl_cdtr_agt { val.validate()? }
		if let Some(ref val) = self.orgnl_cdtr_agt_acct { val.validate()? }
		if let Some(ref val) = self.orgnl_dbtr { val.validate()? }
		if let Some(ref val) = self.orgnl_dbtr_acct { val.validate()? }
		if let Some(ref val) = self.orgnl_dbtr_agt { val.validate()? }
		if let Some(ref val) = self.orgnl_dbtr_agt_acct { val.validate()? }
		if let Some(ref val) = self.orgnl_frqcy { val.validate()? }
		if let Some(ref val) = self.orgnl_rsn { val.validate()? }
		if let Some(ref val) = self.orgnl_trckg_days {
			let pattern = Regex::new("[0-9]{2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "orgnl_trckg_days does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// Amount2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Amount2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AmtWthtCcy", skip_serializing_if = "Option::is_none") )]
	pub amt_wtht_ccy: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AmtWthCcy", skip_serializing_if = "Option::is_none") )]
	pub amt_wth_ccy: Option<ActiveCurrencyAndAmount>,
}

impl Amount2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.amt_wtht_ccy {
			if *val < 0.000000 {
				return Err(ValidationError::new(1003, "amt_wtht_ccy is less than the minimum value of 0.000000".to_string()));
			}
		}
		if let Some(ref val) = self.amt_wth_ccy { val.validate()? }
		Ok(())
	}
}


// Amount3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Amount3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlAmt", skip_serializing_if = "Option::is_none") )]
	pub orgnl_amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgAmt") )]
	pub rptg_amt: ActiveCurrencyAndAmount,
}

impl Amount3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgnl_amt { val.validate()? }
		self.rptg_amt.validate()?;
		Ok(())
	}
}


// Amount3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Amount3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AmtWthCcy", skip_serializing_if = "Option::is_none") )]
	pub amt_wth_ccy: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AmtWthtCcy", skip_serializing_if = "Option::is_none") )]
	pub amt_wtht_ccy: Option<f64>,
}

impl Amount3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.amt_wth_ccy { val.validate()? }
		if let Some(ref val) = self.amt_wtht_ccy {
			if *val < 0.000000 {
				return Err(ValidationError::new(1003, "amt_wtht_ccy is less than the minimum value of 0.000000".to_string()));
			}
		}
		Ok(())
	}
}


// Amount4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Amount4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "IncrAmt", skip_serializing_if = "Option::is_none") )]
	pub incr_amt: Option<Amount2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DcrAmt", skip_serializing_if = "Option::is_none") )]
	pub dcr_amt: Option<Amount2Choice>,
}

impl Amount4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.incr_amt { val.validate()? }
		if let Some(ref val) = self.dcr_amt { val.validate()? }
		Ok(())
	}
}


// AmountAndCurrencyExchange4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AmountAndCurrencyExchange4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstdAmt", skip_serializing_if = "Option::is_none") )]
	pub instd_amt: Option<AmountAndCurrencyExchangeDetails5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxAmt", skip_serializing_if = "Option::is_none") )]
	pub tx_amt: Option<AmountAndCurrencyExchangeDetails5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CntrValAmt", skip_serializing_if = "Option::is_none") )]
	pub cntr_val_amt: Option<AmountAndCurrencyExchangeDetails5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AnncdPstngAmt", skip_serializing_if = "Option::is_none") )]
	pub anncd_pstng_amt: Option<AmountAndCurrencyExchangeDetails5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtryAmt", skip_serializing_if = "Option::is_none") )]
	pub prtry_amt: Option<Vec<AmountAndCurrencyExchangeDetails6>>,
}

impl AmountAndCurrencyExchange4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.instd_amt { val.validate()? }
		if let Some(ref val) = self.tx_amt { val.validate()? }
		if let Some(ref val) = self.cntr_val_amt { val.validate()? }
		if let Some(ref val) = self.anncd_pstng_amt { val.validate()? }
		if let Some(ref vec) = self.prtry_amt { for item in vec { item.validate()? } }
		Ok(())
	}
}


// AmountAndCurrencyExchangeDetails5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AmountAndCurrencyExchangeDetails5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveOrHistoricCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CcyXchg", skip_serializing_if = "Option::is_none") )]
	pub ccy_xchg: Option<CurrencyExchange24>,
}

impl AmountAndCurrencyExchangeDetails5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.amt.validate()?;
		if let Some(ref val) = self.ccy_xchg { val.validate()? }
		Ok(())
	}
}


// AmountAndCurrencyExchangeDetails6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AmountAndCurrencyExchangeDetails6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveOrHistoricCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CcyXchg", skip_serializing_if = "Option::is_none") )]
	pub ccy_xchg: Option<CurrencyExchange24>,
}

impl AmountAndCurrencyExchangeDetails6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.tp.chars().count() < 1 {
			return Err(ValidationError::new(1001, "tp is shorter than the minimum length of 1".to_string()));
		}
		if self.tp.chars().count() > 35 {
			return Err(ValidationError::new(1002, "tp exceeds the maximum length of 35".to_string()));
		}
		self.amt.validate()?;
		if let Some(ref val) = self.ccy_xchg { val.validate()? }
		Ok(())
	}
}


// AmountAndDirection102 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AmountAndDirection102 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sgn") )]
	pub sgn: bool,
}

impl AmountAndDirection102 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.amt.validate()?;
		Ok(())
	}
}


// AmountAndDirection106 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AmountAndDirection106 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveOrHistoricCurrencyAnd19DecimalAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sgn", skip_serializing_if = "Option::is_none") )]
	pub sgn: Option<bool>,
}

impl AmountAndDirection106 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.amt.validate()?;
		Ok(())
	}
}


// AmountAndDirection107 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AmountAndDirection107 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveOrHistoricCurrencyAnd20DecimalAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sgn", skip_serializing_if = "Option::is_none") )]
	pub sgn: Option<bool>,
}

impl AmountAndDirection107 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.amt.validate()?;
		Ok(())
	}
}


// AmountAndDirection109 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AmountAndDirection109 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<ActiveOrHistoricCurrencyAnd19DecimalAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sgn", skip_serializing_if = "Option::is_none") )]
	pub sgn: Option<bool>,
}

impl AmountAndDirection109 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.amt { val.validate()? }
		Ok(())
	}
}


// AmountAndDirection34 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AmountAndDirection34 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveOrHistoricCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sgn") )]
	pub sgn: bool,
}

impl AmountAndDirection34 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.amt.validate()?;
		Ok(())
	}
}


// AmountAndDirection35 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AmountAndDirection35 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbtInd") )]
	pub cdt_dbt_ind: CreditDebitCode,
}

impl AmountAndDirection35 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.amt < 0.000000 {
			return Err(ValidationError::new(1003, "amt is less than the minimum value of 0.000000".to_string()));
		}
		self.cdt_dbt_ind.validate()?;
		Ok(())
	}
}


// AmountAndDirection5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AmountAndDirection5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbt", skip_serializing_if = "Option::is_none") )]
	pub cdt_dbt: Option<CreditDebitCode>,
}

impl AmountAndDirection5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.amt.validate()?;
		if let Some(ref val) = self.cdt_dbt { val.validate()? }
		Ok(())
	}
}


// AmountAndDirection53 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AmountAndDirection53 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveOrHistoricCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sgn", skip_serializing_if = "Option::is_none") )]
	pub sgn: Option<bool>,
}

impl AmountAndDirection53 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.amt.validate()?;
		Ok(())
	}
}


// AmountAndDirection61 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AmountAndDirection61 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveCurrencyAnd13DecimalAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sgn", skip_serializing_if = "Option::is_none") )]
	pub sgn: Option<bool>,
}

impl AmountAndDirection61 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.amt.validate()?;
		Ok(())
	}
}


// AmountAndDirection86 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AmountAndDirection86 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sgn") )]
	pub sgn: bool,
}

impl AmountAndDirection86 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.amt < 0.000000 {
			return Err(ValidationError::new(1003, "amt is less than the minimum value of 0.000000".to_string()));
		}
		Ok(())
	}
}


// AmountAndQuantityBreakdown1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AmountAndQuantityBreakdown1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "LotNb", skip_serializing_if = "Option::is_none") )]
	pub lot_nb: Option<GenericIdentification37>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LotAmt", skip_serializing_if = "Option::is_none") )]
	pub lot_amt: Option<AmountAndDirection5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LotQty", skip_serializing_if = "Option::is_none") )]
	pub lot_qty: Option<FinancialInstrumentQuantity1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshSubBalTp", skip_serializing_if = "Option::is_none") )]
	pub csh_sub_bal_tp: Option<GenericIdentification30>,
}

impl AmountAndQuantityBreakdown1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.lot_nb { val.validate()? }
		if let Some(ref val) = self.lot_amt { val.validate()? }
		if let Some(ref val) = self.lot_qty { val.validate()? }
		if let Some(ref val) = self.csh_sub_bal_tp { val.validate()? }
		Ok(())
	}
}


// AmountHaircutMargin1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AmountHaircutMargin1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: AmountAndDirection53,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HrcutOrMrgn", skip_serializing_if = "Option::is_none") )]
	pub hrcut_or_mrgn: Option<f64>,
}

impl AmountHaircutMargin1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.amt.validate()?;
		Ok(())
	}
}


// AmountModification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AmountModification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModCd", skip_serializing_if = "Option::is_none") )]
	pub mod_cd: Option<Modification1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: f64,
}

impl AmountModification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mod_cd { val.validate()? }
		if self.amt < 0.000000 {
			return Err(ValidationError::new(1003, "amt is less than the minimum value of 0.000000".to_string()));
		}
		Ok(())
	}
}


// AmountOrPercentageRange1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AmountOrPercentageRange1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Opr", skip_serializing_if = "Option::is_none") )]
	pub opr: Option<Operation1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Term", skip_serializing_if = "Option::is_none") )]
	pub term: Option<Vec<Term1>>,
}

impl AmountOrPercentageRange1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.opr { val.validate()? }
		if let Some(ref vec) = self.term { for item in vec { item.validate()? } }
		Ok(())
	}
}


// AmountOrRate1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AmountOrRate1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rate", skip_serializing_if = "Option::is_none") )]
	pub rate: Option<f64>,
}

impl AmountOrRate1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.amt { val.validate()? }
		Ok(())
	}
}


// AmountOrRate3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AmountOrRate3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<ActiveCurrencyAnd13DecimalAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rate", skip_serializing_if = "Option::is_none") )]
	pub rate: Option<f64>,
}

impl AmountOrRate3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.amt { val.validate()? }
		Ok(())
	}
}


// AmountRangeBoundary1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AmountRangeBoundary1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BdryAmt") )]
	pub bdry_amt: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Incl") )]
	pub incl: bool,
}

impl AmountRangeBoundary1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.bdry_amt < 0.000000 {
			return Err(ValidationError::new(1003, "bdry_amt is less than the minimum value of 0.000000".to_string()));
		}
		Ok(())
	}
}


// AmountType3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AmountType3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstdAmt", skip_serializing_if = "Option::is_none") )]
	pub instd_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EqvtAmt", skip_serializing_if = "Option::is_none") )]
	pub eqvt_amt: Option<EquivalentAmount2>,
}

impl AmountType3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.instd_amt { val.validate()? }
		if let Some(ref val) = self.eqvt_amt { val.validate()? }
		Ok(())
	}
}


// AmountType4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AmountType4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstdAmt", skip_serializing_if = "Option::is_none") )]
	pub instd_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EqvtAmt", skip_serializing_if = "Option::is_none") )]
	pub eqvt_amt: Option<EquivalentAmount2>,
}

impl AmountType4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.instd_amt { val.validate()? }
		if let Some(ref val) = self.eqvt_amt { val.validate()? }
		Ok(())
	}
}


// AnnualChargePaymentType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AnnualChargePaymentType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CAPL") )]
	CodeCAPL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INCO") )]
	CodeINCO,
}

impl AnnualChargePaymentType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AnyMIC1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AnyMIC1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ANYM") )]
	CodeANYM,
}

impl AnyMIC1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Appearance1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum Appearance1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "DELI") )]
	CodeDELI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NDEL") )]
	CodeNDEL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LIMI") )]
	CodeLIMI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BENT") )]
	CodeBENT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DFBE") )]
	CodeDFBE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DLBE") )]
	CodeDLBE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TMPG") )]
	CodeTMPG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GLOB") )]
	CodeGLOB,
}

impl Appearance1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Appearance3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Appearance3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<Appearance1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl Appearance3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// ApplicationSpecifics1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ApplicationSpecifics1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SysUsr", skip_serializing_if = "Option::is_none") )]
	pub sys_usr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sgntr", skip_serializing_if = "Option::is_none") )]
	pub sgntr: Option<SignatureEnvelope>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNbOfDocs") )]
	pub ttl_nb_of_docs: f64,
}

impl ApplicationSpecifics1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.sys_usr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "sys_usr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "sys_usr exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.sgntr { val.validate()? }
		Ok(())
	}
}


// AssessmentOfValueRequiredUnderCOLLUKType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssessmentOfValueRequiredUnderCOLLUKType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "YSCO") )]
	CodeYSCO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NSCO") )]
	CodeNSCO,
}

impl AssessmentOfValueRequiredUnderCOLLUKType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClass2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClass2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cmmdty", skip_serializing_if = "Option::is_none") )]
	pub cmmdty: Option<DerivativeCommodity2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Intrst", skip_serializing_if = "Option::is_none") )]
	pub intrst: Option<DerivativeInterest3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FX", skip_serializing_if = "Option::is_none") )]
	pub fx: Option<DerivativeForeignExchange3>,
}

impl AssetClass2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cmmdty { val.validate()? }
		if let Some(ref val) = self.intrst { val.validate()? }
		if let Some(ref val) = self.fx { val.validate()? }
		Ok(())
	}
}


// AssetClassAndSubClassIdentification2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClassAndSubClassIdentification2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AsstClss") )]
	pub asst_clss: NonEquityAssetClass1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DerivSubClss", skip_serializing_if = "Option::is_none") )]
	pub deriv_sub_clss: Option<NonEquitySubClass1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmClssfctn", skip_serializing_if = "Option::is_none") )]
	pub fin_instrm_clssfctn: Option<NonEquityInstrumentReportingClassification1Code>,
}

impl AssetClassAndSubClassIdentification2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.asst_clss.validate()?;
		if let Some(ref val) = self.deriv_sub_clss { val.validate()? }
		if let Some(ref val) = self.fin_instrm_clssfctn { val.validate()? }
		Ok(())
	}
}


// AssetClassAttributes1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClassAttributes1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Intrst") )]
	pub intrst: DerivativeInterest2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FX") )]
	pub fx: DerivativeForeignExchange2,
}

impl AssetClassAttributes1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.intrst.validate()?;
		self.fx.validate()?;
		Ok(())
	}
}


// AssetClassAttributes1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClassAttributes1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Intrst", skip_serializing_if = "Option::is_none") )]
	pub intrst: Option<DerivativeInterest2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FX", skip_serializing_if = "Option::is_none") )]
	pub fx: Option<DerivativeForeignExchange2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Both", skip_serializing_if = "Option::is_none") )]
	pub both: Option<AssetClassAttributes1>,
}

impl AssetClassAttributes1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.intrst { val.validate()? }
		if let Some(ref val) = self.fx { val.validate()? }
		if let Some(ref val) = self.both { val.validate()? }
		Ok(())
	}
}


// AssetClassCommodity3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClassCommodity3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Agrcltrl", skip_serializing_if = "Option::is_none") )]
	pub agrcltrl: Option<AssetClassCommodityAgricultural1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nrgy", skip_serializing_if = "Option::is_none") )]
	pub nrgy: Option<AssetClassCommodityEnergy1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Envttl", skip_serializing_if = "Option::is_none") )]
	pub envttl: Option<AssetClassCommodityEnvironmental1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Frtlzr", skip_serializing_if = "Option::is_none") )]
	pub frtlzr: Option<AssetClassCommodityFertilizer1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Frght", skip_serializing_if = "Option::is_none") )]
	pub frght: Option<AssetClassCommodityFreight1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IndstrlPdct", skip_serializing_if = "Option::is_none") )]
	pub indstrl_pdct: Option<AssetClassCommodityIndustrialProduct1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Metl", skip_serializing_if = "Option::is_none") )]
	pub metl: Option<AssetClassCommodityMetal1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrC10", skip_serializing_if = "Option::is_none") )]
	pub othr_c10: Option<AssetClassCommodityOtherC102Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ppr", skip_serializing_if = "Option::is_none") )]
	pub ppr: Option<AssetClassCommodityPaper1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Plprpln", skip_serializing_if = "Option::is_none") )]
	pub plprpln: Option<AssetClassCommodityPolypropylene1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Infltn", skip_serializing_if = "Option::is_none") )]
	pub infltn: Option<AssetClassCommodityInflation1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MultiCmmdtyExtc", skip_serializing_if = "Option::is_none") )]
	pub multi_cmmdty_extc: Option<AssetClassCommodityMultiCommodityExotic1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OffclEcnmcSttstcs", skip_serializing_if = "Option::is_none") )]
	pub offcl_ecnmc_sttstcs: Option<AssetClassCommodityOfficialEconomicStatistics1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<AssetClassCommodityOther1>,
}

impl AssetClassCommodity3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.agrcltrl { val.validate()? }
		if let Some(ref val) = self.nrgy { val.validate()? }
		if let Some(ref val) = self.envttl { val.validate()? }
		if let Some(ref val) = self.frtlzr { val.validate()? }
		if let Some(ref val) = self.frght { val.validate()? }
		if let Some(ref val) = self.indstrl_pdct { val.validate()? }
		if let Some(ref val) = self.metl { val.validate()? }
		if let Some(ref val) = self.othr_c10 { val.validate()? }
		if let Some(ref val) = self.ppr { val.validate()? }
		if let Some(ref val) = self.plprpln { val.validate()? }
		if let Some(ref val) = self.infltn { val.validate()? }
		if let Some(ref val) = self.multi_cmmdty_extc { val.validate()? }
		if let Some(ref val) = self.offcl_ecnmc_sttstcs { val.validate()? }
		if let Some(ref val) = self.othr { val.validate()? }
		Ok(())
	}
}


// AssetClassCommodity5Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClassCommodity5Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Agrcltrl", skip_serializing_if = "Option::is_none") )]
	pub agrcltrl: Option<AssetClassCommodityAgricultural5Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nrgy", skip_serializing_if = "Option::is_none") )]
	pub nrgy: Option<AssetClassCommodityEnergy2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Envttl", skip_serializing_if = "Option::is_none") )]
	pub envttl: Option<AssetClassCommodityEnvironmental2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Frtlzr", skip_serializing_if = "Option::is_none") )]
	pub frtlzr: Option<AssetClassCommodityFertilizer3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Frght", skip_serializing_if = "Option::is_none") )]
	pub frght: Option<AssetClassCommodityFreight3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IndstrlPdct", skip_serializing_if = "Option::is_none") )]
	pub indstrl_pdct: Option<AssetClassCommodityIndustrialProduct1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Metl", skip_serializing_if = "Option::is_none") )]
	pub metl: Option<AssetClassCommodityMetal1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrC10", skip_serializing_if = "Option::is_none") )]
	pub othr_c10: Option<AssetClassCommodityOtherC102Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ppr", skip_serializing_if = "Option::is_none") )]
	pub ppr: Option<AssetClassCommodityPaper3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Plprpln", skip_serializing_if = "Option::is_none") )]
	pub plprpln: Option<AssetClassCommodityPolypropylene3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Infltn", skip_serializing_if = "Option::is_none") )]
	pub infltn: Option<AssetClassCommodityInflation1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MultiCmmdtyExtc", skip_serializing_if = "Option::is_none") )]
	pub multi_cmmdty_extc: Option<AssetClassCommodityMultiCommodityExotic1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OffclEcnmcSttstcs", skip_serializing_if = "Option::is_none") )]
	pub offcl_ecnmc_sttstcs: Option<AssetClassCommodityOfficialEconomicStatistics1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<AssetClassCommodityOther1>,
}

impl AssetClassCommodity5Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.agrcltrl { val.validate()? }
		if let Some(ref val) = self.nrgy { val.validate()? }
		if let Some(ref val) = self.envttl { val.validate()? }
		if let Some(ref val) = self.frtlzr { val.validate()? }
		if let Some(ref val) = self.frght { val.validate()? }
		if let Some(ref val) = self.indstrl_pdct { val.validate()? }
		if let Some(ref val) = self.metl { val.validate()? }
		if let Some(ref val) = self.othr_c10 { val.validate()? }
		if let Some(ref val) = self.ppr { val.validate()? }
		if let Some(ref val) = self.plprpln { val.validate()? }
		if let Some(ref val) = self.infltn { val.validate()? }
		if let Some(ref val) = self.multi_cmmdty_extc { val.validate()? }
		if let Some(ref val) = self.offcl_ecnmc_sttstcs { val.validate()? }
		if let Some(ref val) = self.othr { val.validate()? }
		Ok(())
	}
}


// AssetClassCommodity6Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClassCommodity6Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Agrcltrl", skip_serializing_if = "Option::is_none") )]
	pub agrcltrl: Option<AssetClassCommodityAgricultural6Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nrgy", skip_serializing_if = "Option::is_none") )]
	pub nrgy: Option<AssetClassCommodityEnergy3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Envttl", skip_serializing_if = "Option::is_none") )]
	pub envttl: Option<AssetClassCommodityEnvironmental3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Frtlzr", skip_serializing_if = "Option::is_none") )]
	pub frtlzr: Option<AssetClassCommodityFertilizer4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Frght", skip_serializing_if = "Option::is_none") )]
	pub frght: Option<AssetClassCommodityFreight4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Indx", skip_serializing_if = "Option::is_none") )]
	pub indx: Option<AssetClassCommodityIndex1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IndstrlPdct", skip_serializing_if = "Option::is_none") )]
	pub indstrl_pdct: Option<AssetClassCommodityIndustrialProduct2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Infltn", skip_serializing_if = "Option::is_none") )]
	pub infltn: Option<AssetClassCommodityInflation1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Metl", skip_serializing_if = "Option::is_none") )]
	pub metl: Option<AssetClassCommodityMetal2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MultiCmmdtyExtc", skip_serializing_if = "Option::is_none") )]
	pub multi_cmmdty_extc: Option<AssetClassCommodityMultiCommodityExotic1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OffclEcnmcSttstcs", skip_serializing_if = "Option::is_none") )]
	pub offcl_ecnmc_sttstcs: Option<AssetClassCommodityOfficialEconomicStatistics1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<AssetClassCommodityOther1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrC10", skip_serializing_if = "Option::is_none") )]
	pub othr_c10: Option<AssetClassCommodityC10Other1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ppr", skip_serializing_if = "Option::is_none") )]
	pub ppr: Option<AssetClassCommodityPaper4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Plprpln", skip_serializing_if = "Option::is_none") )]
	pub plprpln: Option<AssetClassCommodityPolypropylene4Choice>,
}

impl AssetClassCommodity6Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.agrcltrl { val.validate()? }
		if let Some(ref val) = self.nrgy { val.validate()? }
		if let Some(ref val) = self.envttl { val.validate()? }
		if let Some(ref val) = self.frtlzr { val.validate()? }
		if let Some(ref val) = self.frght { val.validate()? }
		if let Some(ref val) = self.indx { val.validate()? }
		if let Some(ref val) = self.indstrl_pdct { val.validate()? }
		if let Some(ref val) = self.infltn { val.validate()? }
		if let Some(ref val) = self.metl { val.validate()? }
		if let Some(ref val) = self.multi_cmmdty_extc { val.validate()? }
		if let Some(ref val) = self.offcl_ecnmc_sttstcs { val.validate()? }
		if let Some(ref val) = self.othr { val.validate()? }
		if let Some(ref val) = self.othr_c10 { val.validate()? }
		if let Some(ref val) = self.ppr { val.validate()? }
		if let Some(ref val) = self.plprpln { val.validate()? }
		Ok(())
	}
}


// AssetClassCommodity7Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClassCommodity7Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Agrcltrl", skip_serializing_if = "Option::is_none") )]
	pub agrcltrl: Option<AssetClassCommodityAgricultural6Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nrgy", skip_serializing_if = "Option::is_none") )]
	pub nrgy: Option<AssetClassCommodityEnergy3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Envttl", skip_serializing_if = "Option::is_none") )]
	pub envttl: Option<AssetClassCommodityEnvironmental3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Frtlzr", skip_serializing_if = "Option::is_none") )]
	pub frtlzr: Option<AssetClassCommodityFertilizer4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Frght", skip_serializing_if = "Option::is_none") )]
	pub frght: Option<AssetClassCommodityFreight4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Indx", skip_serializing_if = "Option::is_none") )]
	pub indx: Option<AssetClassCommodityIndex1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IndstrlPdct", skip_serializing_if = "Option::is_none") )]
	pub indstrl_pdct: Option<AssetClassCommodityIndustrialProduct2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Infltn", skip_serializing_if = "Option::is_none") )]
	pub infltn: Option<AssetClassCommodityInflation1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Metl", skip_serializing_if = "Option::is_none") )]
	pub metl: Option<AssetClassCommodityMetal2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MultiCmmdtyExtc", skip_serializing_if = "Option::is_none") )]
	pub multi_cmmdty_extc: Option<AssetClassCommodityMultiCommodityExotic1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OffclEcnmcSttstcs", skip_serializing_if = "Option::is_none") )]
	pub offcl_ecnmc_sttstcs: Option<AssetClassCommodityOfficialEconomicStatistics1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<AssetClassCommodityOther1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrC10", skip_serializing_if = "Option::is_none") )]
	pub othr_c10: Option<AssetClassCommodityC10Other1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ppr", skip_serializing_if = "Option::is_none") )]
	pub ppr: Option<AssetClassCommodityPaper5Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Plprpln", skip_serializing_if = "Option::is_none") )]
	pub plprpln: Option<AssetClassCommodityPolypropylene4Choice>,
}

impl AssetClassCommodity7Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.agrcltrl { val.validate()? }
		if let Some(ref val) = self.nrgy { val.validate()? }
		if let Some(ref val) = self.envttl { val.validate()? }
		if let Some(ref val) = self.frtlzr { val.validate()? }
		if let Some(ref val) = self.frght { val.validate()? }
		if let Some(ref val) = self.indx { val.validate()? }
		if let Some(ref val) = self.indstrl_pdct { val.validate()? }
		if let Some(ref val) = self.infltn { val.validate()? }
		if let Some(ref val) = self.metl { val.validate()? }
		if let Some(ref val) = self.multi_cmmdty_extc { val.validate()? }
		if let Some(ref val) = self.offcl_ecnmc_sttstcs { val.validate()? }
		if let Some(ref val) = self.othr { val.validate()? }
		if let Some(ref val) = self.othr_c10 { val.validate()? }
		if let Some(ref val) = self.ppr { val.validate()? }
		if let Some(ref val) = self.plprpln { val.validate()? }
		Ok(())
	}
}


// AssetClassCommodityAgricultural1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClassCommodityAgricultural1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "GrnOilSeed", skip_serializing_if = "Option::is_none") )]
	pub grn_oil_seed: Option<AgriculturalCommodityOilSeed1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Soft", skip_serializing_if = "Option::is_none") )]
	pub soft: Option<AgriculturalCommoditySoft1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ptt", skip_serializing_if = "Option::is_none") )]
	pub ptt: Option<AgriculturalCommodityPotato1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OlvOil", skip_serializing_if = "Option::is_none") )]
	pub olv_oil: Option<AgriculturalCommodityOliveOil1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dairy", skip_serializing_if = "Option::is_none") )]
	pub dairy: Option<AgriculturalCommodityDairy1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Frstry", skip_serializing_if = "Option::is_none") )]
	pub frstry: Option<AgriculturalCommodityForestry1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sfd", skip_serializing_if = "Option::is_none") )]
	pub sfd: Option<AgriculturalCommoditySeafood1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LiveStock", skip_serializing_if = "Option::is_none") )]
	pub live_stock: Option<AgriculturalCommodityLiveStock1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Grn", skip_serializing_if = "Option::is_none") )]
	pub grn: Option<AgriculturalCommodityGrain1>,
}

impl AssetClassCommodityAgricultural1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.grn_oil_seed { val.validate()? }
		if let Some(ref val) = self.soft { val.validate()? }
		if let Some(ref val) = self.ptt { val.validate()? }
		if let Some(ref val) = self.olv_oil { val.validate()? }
		if let Some(ref val) = self.dairy { val.validate()? }
		if let Some(ref val) = self.frstry { val.validate()? }
		if let Some(ref val) = self.sfd { val.validate()? }
		if let Some(ref val) = self.live_stock { val.validate()? }
		if let Some(ref val) = self.grn { val.validate()? }
		Ok(())
	}
}


// AssetClassCommodityAgricultural5Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClassCommodityAgricultural5Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "GrnOilSeed", skip_serializing_if = "Option::is_none") )]
	pub grn_oil_seed: Option<AgriculturalCommodityOilSeed1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Soft", skip_serializing_if = "Option::is_none") )]
	pub soft: Option<AgriculturalCommoditySoft1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ptt", skip_serializing_if = "Option::is_none") )]
	pub ptt: Option<AgriculturalCommodityPotato1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OlvOil", skip_serializing_if = "Option::is_none") )]
	pub olv_oil: Option<AgriculturalCommodityOliveOil2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dairy", skip_serializing_if = "Option::is_none") )]
	pub dairy: Option<AgriculturalCommodityDairy1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Frstry", skip_serializing_if = "Option::is_none") )]
	pub frstry: Option<AgriculturalCommodityForestry1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sfd", skip_serializing_if = "Option::is_none") )]
	pub sfd: Option<AgriculturalCommoditySeafood1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LiveStock", skip_serializing_if = "Option::is_none") )]
	pub live_stock: Option<AgriculturalCommodityLiveStock1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Grn", skip_serializing_if = "Option::is_none") )]
	pub grn: Option<AgriculturalCommodityGrain2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<AgriculturalCommodityOther1>,
}

impl AssetClassCommodityAgricultural5Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.grn_oil_seed { val.validate()? }
		if let Some(ref val) = self.soft { val.validate()? }
		if let Some(ref val) = self.ptt { val.validate()? }
		if let Some(ref val) = self.olv_oil { val.validate()? }
		if let Some(ref val) = self.dairy { val.validate()? }
		if let Some(ref val) = self.frstry { val.validate()? }
		if let Some(ref val) = self.sfd { val.validate()? }
		if let Some(ref val) = self.live_stock { val.validate()? }
		if let Some(ref val) = self.grn { val.validate()? }
		if let Some(ref val) = self.othr { val.validate()? }
		Ok(())
	}
}


// AssetClassCommodityAgricultural6Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClassCommodityAgricultural6Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "GrnOilSeed", skip_serializing_if = "Option::is_none") )]
	pub grn_oil_seed: Option<AgriculturalCommodityOilSeed2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Soft", skip_serializing_if = "Option::is_none") )]
	pub soft: Option<AgriculturalCommoditySoft2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ptt", skip_serializing_if = "Option::is_none") )]
	pub ptt: Option<AgriculturalCommodityPotato2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OlvOil", skip_serializing_if = "Option::is_none") )]
	pub olv_oil: Option<AgriculturalCommodityOliveOil3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dairy", skip_serializing_if = "Option::is_none") )]
	pub dairy: Option<AgriculturalCommodityDairy2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Frstry", skip_serializing_if = "Option::is_none") )]
	pub frstry: Option<AgriculturalCommodityForestry2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sfd", skip_serializing_if = "Option::is_none") )]
	pub sfd: Option<AgriculturalCommoditySeafood2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LiveStock", skip_serializing_if = "Option::is_none") )]
	pub live_stock: Option<AgriculturalCommodityLiveStock2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Grn", skip_serializing_if = "Option::is_none") )]
	pub grn: Option<AgriculturalCommodityGrain3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<AgriculturalCommodityOther2>,
}

impl AssetClassCommodityAgricultural6Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.grn_oil_seed { val.validate()? }
		if let Some(ref val) = self.soft { val.validate()? }
		if let Some(ref val) = self.ptt { val.validate()? }
		if let Some(ref val) = self.olv_oil { val.validate()? }
		if let Some(ref val) = self.dairy { val.validate()? }
		if let Some(ref val) = self.frstry { val.validate()? }
		if let Some(ref val) = self.sfd { val.validate()? }
		if let Some(ref val) = self.live_stock { val.validate()? }
		if let Some(ref val) = self.grn { val.validate()? }
		if let Some(ref val) = self.othr { val.validate()? }
		Ok(())
	}
}


// AssetClassCommodityC10Other1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClassCommodityC10Other1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType11Code,
}

impl AssetClassCommodityC10Other1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		Ok(())
	}
}


// AssetClassCommodityEnergy1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClassCommodityEnergy1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Elctrcty", skip_serializing_if = "Option::is_none") )]
	pub elctrcty: Option<EnergyCommodityElectricity1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtrlGas", skip_serializing_if = "Option::is_none") )]
	pub ntrl_gas: Option<EnergyCommodityNaturalGas1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Oil", skip_serializing_if = "Option::is_none") )]
	pub oil: Option<EnergyCommodityOil1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Coal", skip_serializing_if = "Option::is_none") )]
	pub coal: Option<EnergyCommodityCoal1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrNrgy", skip_serializing_if = "Option::is_none") )]
	pub intr_nrgy: Option<EnergyCommodityInterEnergy1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RnwblNrgy", skip_serializing_if = "Option::is_none") )]
	pub rnwbl_nrgy: Option<EnergyCommodityRenewableEnergy1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LghtEnd", skip_serializing_if = "Option::is_none") )]
	pub lght_end: Option<EnergyCommodityLightEnd1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dstllts", skip_serializing_if = "Option::is_none") )]
	pub dstllts: Option<EnergyCommodityDistillates1>,
}

impl AssetClassCommodityEnergy1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.elctrcty { val.validate()? }
		if let Some(ref val) = self.ntrl_gas { val.validate()? }
		if let Some(ref val) = self.oil { val.validate()? }
		if let Some(ref val) = self.coal { val.validate()? }
		if let Some(ref val) = self.intr_nrgy { val.validate()? }
		if let Some(ref val) = self.rnwbl_nrgy { val.validate()? }
		if let Some(ref val) = self.lght_end { val.validate()? }
		if let Some(ref val) = self.dstllts { val.validate()? }
		Ok(())
	}
}


// AssetClassCommodityEnergy2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClassCommodityEnergy2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Elctrcty", skip_serializing_if = "Option::is_none") )]
	pub elctrcty: Option<EnergyCommodityElectricity1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtrlGas", skip_serializing_if = "Option::is_none") )]
	pub ntrl_gas: Option<EnergyCommodityNaturalGas2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Oil", skip_serializing_if = "Option::is_none") )]
	pub oil: Option<EnergyCommodityOil2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Coal", skip_serializing_if = "Option::is_none") )]
	pub coal: Option<EnergyCommodityCoal1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrNrgy", skip_serializing_if = "Option::is_none") )]
	pub intr_nrgy: Option<EnergyCommodityInterEnergy1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RnwblNrgy", skip_serializing_if = "Option::is_none") )]
	pub rnwbl_nrgy: Option<EnergyCommodityRenewableEnergy1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LghtEnd", skip_serializing_if = "Option::is_none") )]
	pub lght_end: Option<EnergyCommodityLightEnd1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dstllts", skip_serializing_if = "Option::is_none") )]
	pub dstllts: Option<EnergyCommodityDistillates1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<EnergyCommodityOther1>,
}

impl AssetClassCommodityEnergy2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.elctrcty { val.validate()? }
		if let Some(ref val) = self.ntrl_gas { val.validate()? }
		if let Some(ref val) = self.oil { val.validate()? }
		if let Some(ref val) = self.coal { val.validate()? }
		if let Some(ref val) = self.intr_nrgy { val.validate()? }
		if let Some(ref val) = self.rnwbl_nrgy { val.validate()? }
		if let Some(ref val) = self.lght_end { val.validate()? }
		if let Some(ref val) = self.dstllts { val.validate()? }
		if let Some(ref val) = self.othr { val.validate()? }
		Ok(())
	}
}


// AssetClassCommodityEnergy3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClassCommodityEnergy3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Elctrcty", skip_serializing_if = "Option::is_none") )]
	pub elctrcty: Option<EnergyCommodityElectricity2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtrlGas", skip_serializing_if = "Option::is_none") )]
	pub ntrl_gas: Option<EnergyCommodityNaturalGas3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Oil", skip_serializing_if = "Option::is_none") )]
	pub oil: Option<EnergyCommodityOil3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Coal", skip_serializing_if = "Option::is_none") )]
	pub coal: Option<EnergyCommodityCoal2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrNrgy", skip_serializing_if = "Option::is_none") )]
	pub intr_nrgy: Option<EnergyCommodityInterEnergy2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RnwblNrgy", skip_serializing_if = "Option::is_none") )]
	pub rnwbl_nrgy: Option<EnergyCommodityRenewableEnergy2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LghtEnd", skip_serializing_if = "Option::is_none") )]
	pub lght_end: Option<EnergyCommodityLightEnd2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dstllts", skip_serializing_if = "Option::is_none") )]
	pub dstllts: Option<EnergyCommodityDistillates2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<EnergyCommodityOther2>,
}

impl AssetClassCommodityEnergy3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.elctrcty { val.validate()? }
		if let Some(ref val) = self.ntrl_gas { val.validate()? }
		if let Some(ref val) = self.oil { val.validate()? }
		if let Some(ref val) = self.coal { val.validate()? }
		if let Some(ref val) = self.intr_nrgy { val.validate()? }
		if let Some(ref val) = self.rnwbl_nrgy { val.validate()? }
		if let Some(ref val) = self.lght_end { val.validate()? }
		if let Some(ref val) = self.dstllts { val.validate()? }
		if let Some(ref val) = self.othr { val.validate()? }
		Ok(())
	}
}


// AssetClassCommodityEnvironmental1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClassCommodityEnvironmental1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Emssns", skip_serializing_if = "Option::is_none") )]
	pub emssns: Option<EnvironmentalCommodityEmission1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Wthr", skip_serializing_if = "Option::is_none") )]
	pub wthr: Option<EnvironmentalCommodityWeather1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CrbnRltd", skip_serializing_if = "Option::is_none") )]
	pub crbn_rltd: Option<EnvironmentalCommodityCarbonRelated1>,
}

impl AssetClassCommodityEnvironmental1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.emssns { val.validate()? }
		if let Some(ref val) = self.wthr { val.validate()? }
		if let Some(ref val) = self.crbn_rltd { val.validate()? }
		Ok(())
	}
}


// AssetClassCommodityEnvironmental2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClassCommodityEnvironmental2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Emssns", skip_serializing_if = "Option::is_none") )]
	pub emssns: Option<EnvironmentalCommodityEmission2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Wthr", skip_serializing_if = "Option::is_none") )]
	pub wthr: Option<EnvironmentalCommodityWeather1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CrbnRltd", skip_serializing_if = "Option::is_none") )]
	pub crbn_rltd: Option<EnvironmentalCommodityCarbonRelated1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<EnvironmentCommodityOther1>,
}

impl AssetClassCommodityEnvironmental2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.emssns { val.validate()? }
		if let Some(ref val) = self.wthr { val.validate()? }
		if let Some(ref val) = self.crbn_rltd { val.validate()? }
		if let Some(ref val) = self.othr { val.validate()? }
		Ok(())
	}
}


// AssetClassCommodityEnvironmental3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClassCommodityEnvironmental3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Emssns", skip_serializing_if = "Option::is_none") )]
	pub emssns: Option<EnvironmentalCommodityEmission3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Wthr", skip_serializing_if = "Option::is_none") )]
	pub wthr: Option<EnvironmentalCommodityWeather2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CrbnRltd", skip_serializing_if = "Option::is_none") )]
	pub crbn_rltd: Option<EnvironmentalCommodityCarbonRelated2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<EnvironmentCommodityOther2>,
}

impl AssetClassCommodityEnvironmental3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.emssns { val.validate()? }
		if let Some(ref val) = self.wthr { val.validate()? }
		if let Some(ref val) = self.crbn_rltd { val.validate()? }
		if let Some(ref val) = self.othr { val.validate()? }
		Ok(())
	}
}


// AssetClassCommodityFertilizer1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClassCommodityFertilizer1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ammn", skip_serializing_if = "Option::is_none") )]
	pub ammn: Option<FertilizerCommodityAmmonia1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DmmnmPhspht", skip_serializing_if = "Option::is_none") )]
	pub dmmnm_phspht: Option<FertilizerCommodityDiammoniumPhosphate1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ptsh", skip_serializing_if = "Option::is_none") )]
	pub ptsh: Option<FertilizerCommodityPotash1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Slphr", skip_serializing_if = "Option::is_none") )]
	pub slphr: Option<FertilizerCommoditySulphur1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Urea", skip_serializing_if = "Option::is_none") )]
	pub urea: Option<FertilizerCommodityUrea1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UreaAndAmmnmNtrt", skip_serializing_if = "Option::is_none") )]
	pub urea_and_ammnm_ntrt: Option<FertilizerCommodityUreaAndAmmoniumNitrate1>,
}

impl AssetClassCommodityFertilizer1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ammn { val.validate()? }
		if let Some(ref val) = self.dmmnm_phspht { val.validate()? }
		if let Some(ref val) = self.ptsh { val.validate()? }
		if let Some(ref val) = self.slphr { val.validate()? }
		if let Some(ref val) = self.urea { val.validate()? }
		if let Some(ref val) = self.urea_and_ammnm_ntrt { val.validate()? }
		Ok(())
	}
}


// AssetClassCommodityFertilizer3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClassCommodityFertilizer3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ammn", skip_serializing_if = "Option::is_none") )]
	pub ammn: Option<FertilizerCommodityAmmonia1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DmmnmPhspht", skip_serializing_if = "Option::is_none") )]
	pub dmmnm_phspht: Option<FertilizerCommodityDiammoniumPhosphate1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ptsh", skip_serializing_if = "Option::is_none") )]
	pub ptsh: Option<FertilizerCommodityPotash1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Slphr", skip_serializing_if = "Option::is_none") )]
	pub slphr: Option<FertilizerCommoditySulphur1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Urea", skip_serializing_if = "Option::is_none") )]
	pub urea: Option<FertilizerCommodityUrea1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UreaAndAmmnmNtrt", skip_serializing_if = "Option::is_none") )]
	pub urea_and_ammnm_ntrt: Option<FertilizerCommodityUreaAndAmmoniumNitrate1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<FertilizerCommodityOther1>,
}

impl AssetClassCommodityFertilizer3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ammn { val.validate()? }
		if let Some(ref val) = self.dmmnm_phspht { val.validate()? }
		if let Some(ref val) = self.ptsh { val.validate()? }
		if let Some(ref val) = self.slphr { val.validate()? }
		if let Some(ref val) = self.urea { val.validate()? }
		if let Some(ref val) = self.urea_and_ammnm_ntrt { val.validate()? }
		if let Some(ref val) = self.othr { val.validate()? }
		Ok(())
	}
}


// AssetClassCommodityFertilizer4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClassCommodityFertilizer4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ammn", skip_serializing_if = "Option::is_none") )]
	pub ammn: Option<FertilizerCommodityAmmonia2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DmmnmPhspht", skip_serializing_if = "Option::is_none") )]
	pub dmmnm_phspht: Option<FertilizerCommodityDiammoniumPhosphate2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ptsh", skip_serializing_if = "Option::is_none") )]
	pub ptsh: Option<FertilizerCommodityPotash2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Slphr", skip_serializing_if = "Option::is_none") )]
	pub slphr: Option<FertilizerCommoditySulphur2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Urea", skip_serializing_if = "Option::is_none") )]
	pub urea: Option<FertilizerCommodityUrea2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UreaAndAmmnmNtrt", skip_serializing_if = "Option::is_none") )]
	pub urea_and_ammnm_ntrt: Option<FertilizerCommodityUreaAndAmmoniumNitrate2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<FertilizerCommodityOther2>,
}

impl AssetClassCommodityFertilizer4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ammn { val.validate()? }
		if let Some(ref val) = self.dmmnm_phspht { val.validate()? }
		if let Some(ref val) = self.ptsh { val.validate()? }
		if let Some(ref val) = self.slphr { val.validate()? }
		if let Some(ref val) = self.urea { val.validate()? }
		if let Some(ref val) = self.urea_and_ammnm_ntrt { val.validate()? }
		if let Some(ref val) = self.othr { val.validate()? }
		Ok(())
	}
}


// AssetClassCommodityFreight1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClassCommodityFreight1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dry", skip_serializing_if = "Option::is_none") )]
	pub dry: Option<FreightCommodityDry1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Wet", skip_serializing_if = "Option::is_none") )]
	pub wet: Option<FreightCommodityWet1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CntnrShip", skip_serializing_if = "Option::is_none") )]
	pub cntnr_ship: Option<FreightCommodityContainerShip1>,
}

impl AssetClassCommodityFreight1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.dry { val.validate()? }
		if let Some(ref val) = self.wet { val.validate()? }
		if let Some(ref val) = self.cntnr_ship { val.validate()? }
		Ok(())
	}
}


// AssetClassCommodityFreight3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClassCommodityFreight3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dry", skip_serializing_if = "Option::is_none") )]
	pub dry: Option<FreightCommodityDry2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Wet", skip_serializing_if = "Option::is_none") )]
	pub wet: Option<FreightCommodityWet2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CntnrShip", skip_serializing_if = "Option::is_none") )]
	pub cntnr_ship: Option<FreightCommodityContainerShip1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<FreightCommodityOther1>,
}

impl AssetClassCommodityFreight3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.dry { val.validate()? }
		if let Some(ref val) = self.wet { val.validate()? }
		if let Some(ref val) = self.cntnr_ship { val.validate()? }
		if let Some(ref val) = self.othr { val.validate()? }
		Ok(())
	}
}


// AssetClassCommodityFreight4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClassCommodityFreight4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dry", skip_serializing_if = "Option::is_none") )]
	pub dry: Option<FreightCommodityDry3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Wet", skip_serializing_if = "Option::is_none") )]
	pub wet: Option<FreightCommodityWet3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CntnrShip", skip_serializing_if = "Option::is_none") )]
	pub cntnr_ship: Option<FreightCommodityContainerShip2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<FreightCommodityOther2>,
}

impl AssetClassCommodityFreight4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.dry { val.validate()? }
		if let Some(ref val) = self.wet { val.validate()? }
		if let Some(ref val) = self.cntnr_ship { val.validate()? }
		if let Some(ref val) = self.othr { val.validate()? }
		Ok(())
	}
}


// AssetClassCommodityIndex1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClassCommodityIndex1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType16Code,
}

impl AssetClassCommodityIndex1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		Ok(())
	}
}


// AssetClassCommodityIndustrialProduct1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClassCommodityIndustrialProduct1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cnstrctn", skip_serializing_if = "Option::is_none") )]
	pub cnstrctn: Option<IndustrialProductCommodityConstruction1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Manfctg", skip_serializing_if = "Option::is_none") )]
	pub manfctg: Option<IndustrialProductCommodityManufacturing1>,
}

impl AssetClassCommodityIndustrialProduct1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cnstrctn { val.validate()? }
		if let Some(ref val) = self.manfctg { val.validate()? }
		Ok(())
	}
}


// AssetClassCommodityIndustrialProduct2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClassCommodityIndustrialProduct2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cnstrctn", skip_serializing_if = "Option::is_none") )]
	pub cnstrctn: Option<IndustrialProductCommodityConstruction2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Manfctg", skip_serializing_if = "Option::is_none") )]
	pub manfctg: Option<IndustrialProductCommodityManufacturing2>,
}

impl AssetClassCommodityIndustrialProduct2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cnstrctn { val.validate()? }
		if let Some(ref val) = self.manfctg { val.validate()? }
		Ok(())
	}
}


// AssetClassCommodityInflation1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClassCommodityInflation1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType12Code,
}

impl AssetClassCommodityInflation1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		Ok(())
	}
}


// AssetClassCommodityMetal1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClassCommodityMetal1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NonPrcs", skip_serializing_if = "Option::is_none") )]
	pub non_prcs: Option<MetalCommodityNonPrecious1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prcs", skip_serializing_if = "Option::is_none") )]
	pub prcs: Option<MetalCommodityPrecious1>,
}

impl AssetClassCommodityMetal1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.non_prcs { val.validate()? }
		if let Some(ref val) = self.prcs { val.validate()? }
		Ok(())
	}
}


// AssetClassCommodityMetal2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClassCommodityMetal2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NonPrcs", skip_serializing_if = "Option::is_none") )]
	pub non_prcs: Option<MetalCommodityNonPrecious2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prcs", skip_serializing_if = "Option::is_none") )]
	pub prcs: Option<MetalCommodityPrecious2>,
}

impl AssetClassCommodityMetal2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.non_prcs { val.validate()? }
		if let Some(ref val) = self.prcs { val.validate()? }
		Ok(())
	}
}


// AssetClassCommodityMultiCommodityExotic1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClassCommodityMultiCommodityExotic1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType13Code,
}

impl AssetClassCommodityMultiCommodityExotic1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		Ok(())
	}
}


// AssetClassCommodityOfficialEconomicStatistics1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClassCommodityOfficialEconomicStatistics1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType14Code,
}

impl AssetClassCommodityOfficialEconomicStatistics1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		Ok(())
	}
}


// AssetClassCommodityOther1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClassCommodityOther1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType15Code,
}

impl AssetClassCommodityOther1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		Ok(())
	}
}


// AssetClassCommodityOtherC102Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClassCommodityOtherC102Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dlvrbl", skip_serializing_if = "Option::is_none") )]
	pub dlvrbl: Option<OtherC10CommodityDeliverable2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NonDlvrbl", skip_serializing_if = "Option::is_none") )]
	pub non_dlvrbl: Option<OtherC10CommodityNonDeliverable2>,
}

impl AssetClassCommodityOtherC102Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.dlvrbl { val.validate()? }
		if let Some(ref val) = self.non_dlvrbl { val.validate()? }
		Ok(())
	}
}


// AssetClassCommodityPaper1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClassCommodityPaper1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CntnrBrd", skip_serializing_if = "Option::is_none") )]
	pub cntnr_brd: Option<PaperCommodityContainerBoard1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nwsprnt", skip_serializing_if = "Option::is_none") )]
	pub nwsprnt: Option<PaperCommodityNewsprint1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pulp", skip_serializing_if = "Option::is_none") )]
	pub pulp: Option<PaperCommodityPulp1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RcvrdPpr", skip_serializing_if = "Option::is_none") )]
	pub rcvrd_ppr: Option<PaperCommodityRecoveredPaper1>,
}

impl AssetClassCommodityPaper1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cntnr_brd { val.validate()? }
		if let Some(ref val) = self.nwsprnt { val.validate()? }
		if let Some(ref val) = self.pulp { val.validate()? }
		if let Some(ref val) = self.rcvrd_ppr { val.validate()? }
		Ok(())
	}
}


// AssetClassCommodityPaper3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClassCommodityPaper3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CntnrBrd", skip_serializing_if = "Option::is_none") )]
	pub cntnr_brd: Option<PaperCommodityContainerBoard1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nwsprnt", skip_serializing_if = "Option::is_none") )]
	pub nwsprnt: Option<PaperCommodityNewsprint1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pulp", skip_serializing_if = "Option::is_none") )]
	pub pulp: Option<PaperCommodityPulp1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RcvrdPpr", skip_serializing_if = "Option::is_none") )]
	pub rcvrd_ppr: Option<PaperCommodityRecoveredPaper1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<PaperCommodityRecoveredPaper2>,
}

impl AssetClassCommodityPaper3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cntnr_brd { val.validate()? }
		if let Some(ref val) = self.nwsprnt { val.validate()? }
		if let Some(ref val) = self.pulp { val.validate()? }
		if let Some(ref val) = self.rcvrd_ppr { val.validate()? }
		if let Some(ref val) = self.othr { val.validate()? }
		Ok(())
	}
}


// AssetClassCommodityPaper4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClassCommodityPaper4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CntnrBrd", skip_serializing_if = "Option::is_none") )]
	pub cntnr_brd: Option<PaperCommodityContainerBoard2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nwsprnt", skip_serializing_if = "Option::is_none") )]
	pub nwsprnt: Option<PaperCommodityNewsprint2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pulp", skip_serializing_if = "Option::is_none") )]
	pub pulp: Option<PaperCommodityPulp2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RcvrdPpr", skip_serializing_if = "Option::is_none") )]
	pub rcvrd_ppr: Option<PaperCommodityOther1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<PaperCommodityOther1>,
}

impl AssetClassCommodityPaper4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cntnr_brd { val.validate()? }
		if let Some(ref val) = self.nwsprnt { val.validate()? }
		if let Some(ref val) = self.pulp { val.validate()? }
		if let Some(ref val) = self.rcvrd_ppr { val.validate()? }
		if let Some(ref val) = self.othr { val.validate()? }
		Ok(())
	}
}


// AssetClassCommodityPaper5Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClassCommodityPaper5Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CntnrBrd", skip_serializing_if = "Option::is_none") )]
	pub cntnr_brd: Option<PaperCommodityContainerBoard2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nwsprnt", skip_serializing_if = "Option::is_none") )]
	pub nwsprnt: Option<PaperCommodityNewsprint2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pulp", skip_serializing_if = "Option::is_none") )]
	pub pulp: Option<PaperCommodityPulp2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RcvrdPpr", skip_serializing_if = "Option::is_none") )]
	pub rcvrd_ppr: Option<PaperCommodityRecoveredPaper3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<PaperCommodityOther1>,
}

impl AssetClassCommodityPaper5Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cntnr_brd { val.validate()? }
		if let Some(ref val) = self.nwsprnt { val.validate()? }
		if let Some(ref val) = self.pulp { val.validate()? }
		if let Some(ref val) = self.rcvrd_ppr { val.validate()? }
		if let Some(ref val) = self.othr { val.validate()? }
		Ok(())
	}
}


// AssetClassCommodityPolypropylene1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClassCommodityPolypropylene1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Plstc", skip_serializing_if = "Option::is_none") )]
	pub plstc: Option<PolypropyleneCommodityPlastic1>,
}

impl AssetClassCommodityPolypropylene1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.plstc { val.validate()? }
		Ok(())
	}
}


// AssetClassCommodityPolypropylene3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClassCommodityPolypropylene3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Plstc", skip_serializing_if = "Option::is_none") )]
	pub plstc: Option<PolypropyleneCommodityPlastic1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<PolypropyleneCommodityOther1>,
}

impl AssetClassCommodityPolypropylene3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.plstc { val.validate()? }
		if let Some(ref val) = self.othr { val.validate()? }
		Ok(())
	}
}


// AssetClassCommodityPolypropylene4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClassCommodityPolypropylene4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Plstc", skip_serializing_if = "Option::is_none") )]
	pub plstc: Option<PolypropyleneCommodityPlastic2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<PolypropyleneCommodityOther2>,
}

impl AssetClassCommodityPolypropylene4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.plstc { val.validate()? }
		if let Some(ref val) = self.othr { val.validate()? }
		Ok(())
	}
}


// AssetClassDetailedSubProductType10Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassDetailedSubProductType10Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ALUM") )]
	CodeALUM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ALUA") )]
	CodeALUA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CBLT") )]
	CodeCBLT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "COPR") )]
	CodeCOPR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IRON") )]
	CodeIRON,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MOLY") )]
	CodeMOLY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NASC") )]
	CodeNASC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NICK") )]
	CodeNICK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "STEL") )]
	CodeSTEL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TINN") )]
	CodeTINN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ZINC") )]
	CodeZINC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LEAD") )]
	CodeLEAD,
}

impl AssetClassDetailedSubProductType10Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassDetailedSubProductType11Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassDetailedSubProductType11Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "GOLD") )]
	CodeGOLD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PLDM") )]
	CodePLDM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PTNM") )]
	CodePTNM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SLVR") )]
	CodeSLVR,
}

impl AssetClassDetailedSubProductType11Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassDetailedSubProductType12Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassDetailedSubProductType12Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "TNKR") )]
	CodeTNKR,
}

impl AssetClassDetailedSubProductType12Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassDetailedSubProductType14Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassDetailedSubProductType14Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "DBCR") )]
	CodeDBCR,
}

impl AssetClassDetailedSubProductType14Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassDetailedSubProductType15Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassDetailedSubProductType15Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "MWHT") )]
	CodeMWHT,
}

impl AssetClassDetailedSubProductType15Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassDetailedSubProductType16Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassDetailedSubProductType16Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "FXCR") )]
	CodeFXCR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FXEM") )]
	CodeFXEM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FXMJ") )]
	CodeFXMJ,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FUEL") )]
	CodeFUEL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FOIL") )]
	CodeFOIL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GOIL") )]
	CodeGOIL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GSLN") )]
	CodeGSLN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GASP") )]
	CodeGASP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HEAT") )]
	CodeHEAT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IRON") )]
	CodeIRON,
	#[cfg_attr( feature = "derive_serde", serde(rename = "JTFL") )]
	CodeJTFL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "KERO") )]
	CodeKERO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LAMP") )]
	CodeLAMP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LEAD") )]
	CodeLEAD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LLSO") )]
	CodeLLSO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LNGG") )]
	CodeLNGG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CORN") )]
	CodeCORN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MARS") )]
	CodeMARS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MWHT") )]
	CodeMWHT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MOLY") )]
	CodeMOLY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NAPH") )]
	CodeNAPH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NBPG") )]
	CodeNBPG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NASC") )]
	CodeNASC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NCGG") )]
	CodeNCGG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NGLO") )]
	CodeNGLO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NICK") )]
	CodeNICK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OFFP") )]
	CodeOFFP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ALUM") )]
	CodeALUM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ALUA") )]
	CodeALUA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BAKK") )]
	CodeBAKK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BSLD") )]
	CodeBSLD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BDSL") )]
	CodeBDSL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BRNT") )]
	CodeBRNT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BRNX") )]
	CodeBRNX,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CNDA") )]
	CodeCNDA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CERE") )]
	CodeCERE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CBLT") )]
	CodeCBLT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CCOA") )]
	CodeCCOA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "COND") )]
	CodeCOND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CSHP") )]
	CodeCSHP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "COPR") )]
	CodeCOPR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DSEL") )]
	CodeDSEL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DBCR") )]
	CodeDBCR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DUBA") )]
	CodeDUBA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ERUE") )]
	CodeERUE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ESPO") )]
	CodeESPO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ETHA") )]
	CodeETHA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EUAE") )]
	CodeEUAE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EUAA") )]
	CodeEUAA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FWHT") )]
	CodeFWHT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FITR") )]
	CodeFITR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PLDM") )]
	CodePLDM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PKLD") )]
	CodePKLD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PTNM") )]
	CodePTNM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "POTA") )]
	CodePOTA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RPSD") )]
	CodeRPSD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BRWN") )]
	CodeBRWN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RICE") )]
	CodeRICE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ROBU") )]
	CodeROBU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SLVR") )]
	CodeSLVR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SOYB") )]
	CodeSOYB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "STEL") )]
	CodeSTEL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TNKR") )]
	CodeTNKR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TAPI") )]
	CodeTAPI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TINN") )]
	CodeTINN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TTFG") )]
	CodeTTFG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "URAL") )]
	CodeURAL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WHSG") )]
	CodeWHSG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WTIO") )]
	CodeWTIO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ZINC") )]
	CodeZINC,
}

impl AssetClassDetailedSubProductType16Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassDetailedSubProductType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetClassDetailedSubProductType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<AssetClassDetailedSubProductType16Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification36>,
}

impl AssetClassDetailedSubProductType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// AssetClassDetailedSubProductType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassDetailedSubProductType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "FWHT") )]
	CodeFWHT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SOYB") )]
	CodeSOYB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RPSD") )]
	CodeRPSD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CORN") )]
	CodeCORN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RICE") )]
	CodeRICE,
}

impl AssetClassDetailedSubProductType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassDetailedSubProductType29Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassDetailedSubProductType29Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "LAMP") )]
	CodeLAMP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
}

impl AssetClassDetailedSubProductType29Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassDetailedSubProductType2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassDetailedSubProductType2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ROBU") )]
	CodeROBU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CCOA") )]
	CodeCCOA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BRWN") )]
	CodeBRWN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WHSG") )]
	CodeWHSG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
}

impl AssetClassDetailedSubProductType2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassDetailedSubProductType30Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassDetailedSubProductType30Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "MWHT") )]
	CodeMWHT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
}

impl AssetClassDetailedSubProductType30Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassDetailedSubProductType31Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassDetailedSubProductType31Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "GASP") )]
	CodeGASP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LNGG") )]
	CodeLNGG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NCGG") )]
	CodeNCGG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TTFG") )]
	CodeTTFG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NBPG") )]
	CodeNBPG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
}

impl AssetClassDetailedSubProductType31Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassDetailedSubProductType32Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassDetailedSubProductType32Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "BAKK") )]
	CodeBAKK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BDSL") )]
	CodeBDSL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BRNT") )]
	CodeBRNT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BRNX") )]
	CodeBRNX,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CNDA") )]
	CodeCNDA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "COND") )]
	CodeCOND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DSEL") )]
	CodeDSEL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DUBA") )]
	CodeDUBA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ESPO") )]
	CodeESPO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ETHA") )]
	CodeETHA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FUEL") )]
	CodeFUEL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FOIL") )]
	CodeFOIL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GOIL") )]
	CodeGOIL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GSLN") )]
	CodeGSLN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HEAT") )]
	CodeHEAT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "JTFL") )]
	CodeJTFL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "KERO") )]
	CodeKERO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LLSO") )]
	CodeLLSO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MARS") )]
	CodeMARS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NAPH") )]
	CodeNAPH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NGLO") )]
	CodeNGLO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TAPI") )]
	CodeTAPI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WTIO") )]
	CodeWTIO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "URAL") )]
	CodeURAL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
}

impl AssetClassDetailedSubProductType32Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassDetailedSubProductType33Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassDetailedSubProductType33Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "DBCR") )]
	CodeDBCR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
}

impl AssetClassDetailedSubProductType33Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassDetailedSubProductType34Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassDetailedSubProductType34Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "TNKR") )]
	CodeTNKR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
}

impl AssetClassDetailedSubProductType34Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassDetailedSubProductType4Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassDetailedSubProductType4Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "LAMP") )]
	CodeLAMP,
}

impl AssetClassDetailedSubProductType4Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassDetailedSubProductType5Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassDetailedSubProductType5Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "BSLD") )]
	CodeBSLD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FITR") )]
	CodeFITR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PKLD") )]
	CodePKLD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OFFP") )]
	CodeOFFP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
}

impl AssetClassDetailedSubProductType5Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassDetailedSubProductType6Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassDetailedSubProductType6Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "GASP") )]
	CodeGASP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LNGG") )]
	CodeLNGG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NCGG") )]
	CodeNCGG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TTFG") )]
	CodeTTFG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NBPG") )]
	CodeNBPG,
}

impl AssetClassDetailedSubProductType6Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassDetailedSubProductType7Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassDetailedSubProductType7Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "BAKK") )]
	CodeBAKK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BDSL") )]
	CodeBDSL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BRNT") )]
	CodeBRNT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BRNX") )]
	CodeBRNX,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CNDA") )]
	CodeCNDA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "COND") )]
	CodeCOND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DSEL") )]
	CodeDSEL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DUBA") )]
	CodeDUBA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ESPO") )]
	CodeESPO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ETHA") )]
	CodeETHA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FUEL") )]
	CodeFUEL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FOIL") )]
	CodeFOIL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GOIL") )]
	CodeGOIL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GSLN") )]
	CodeGSLN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HEAT") )]
	CodeHEAT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "JTFL") )]
	CodeJTFL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "KERO") )]
	CodeKERO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LLSO") )]
	CodeLLSO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MARS") )]
	CodeMARS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NAPH") )]
	CodeNAPH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NGLO") )]
	CodeNGLO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TAPI") )]
	CodeTAPI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WTIO") )]
	CodeWTIO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "URAL") )]
	CodeURAL,
}

impl AssetClassDetailedSubProductType7Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassDetailedSubProductType8Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassDetailedSubProductType8Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CERE") )]
	CodeCERE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ERUE") )]
	CodeERUE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EUAE") )]
	CodeEUAE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EUAA") )]
	CodeEUAA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
}

impl AssetClassDetailedSubProductType8Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassProductType11Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassProductType11Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHC") )]
	CodeOTHC,
}

impl AssetClassProductType11Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassProductType12Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassProductType12Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "INFL") )]
	CodeINFL,
}

impl AssetClassProductType12Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassProductType13Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassProductType13Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "MCEX") )]
	CodeMCEX,
}

impl AssetClassProductType13Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassProductType14Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassProductType14Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "OEST") )]
	CodeOEST,
}

impl AssetClassProductType14Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassProductType15Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassProductType15Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
}

impl AssetClassProductType15Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassProductType16Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassProductType16Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "INDX") )]
	CodeINDX,
}

impl AssetClassProductType16Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassProductType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassProductType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "AGRI") )]
	CodeAGRI,
}

impl AssetClassProductType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassProductType2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassProductType2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "NRGY") )]
	CodeNRGY,
}

impl AssetClassProductType2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassProductType3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassProductType3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ENVR") )]
	CodeENVR,
}

impl AssetClassProductType3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassProductType4Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassProductType4Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "FRGT") )]
	CodeFRGT,
}

impl AssetClassProductType4Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassProductType5Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassProductType5Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "FRTL") )]
	CodeFRTL,
}

impl AssetClassProductType5Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassProductType6Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassProductType6Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "INDP") )]
	CodeINDP,
}

impl AssetClassProductType6Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassProductType7Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassProductType7Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "METL") )]
	CodeMETL,
}

impl AssetClassProductType7Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassProductType8Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassProductType8Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "PAPR") )]
	CodePAPR,
}

impl AssetClassProductType8Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassProductType9Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassProductType9Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "POLY") )]
	CodePOLY,
}

impl AssetClassProductType9Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType10Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType10Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "EMIS") )]
	CodeEMIS,
}

impl AssetClassSubProductType10Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType15Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType15Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "NPRM") )]
	CodeNPRM,
}

impl AssetClassSubProductType15Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType16Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType16Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRME") )]
	CodePRME,
}

impl AssetClassSubProductType16Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType18Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType18Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "PLST") )]
	CodePLST,
}

impl AssetClassSubProductType18Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType19Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType19Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "DLVR") )]
	CodeDLVR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NDLV") )]
	CodeNDLV,
}

impl AssetClassSubProductType19Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "GROS") )]
	CodeGROS,
}

impl AssetClassSubProductType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType20Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType20Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "DIRY") )]
	CodeDIRY,
}

impl AssetClassSubProductType20Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType21Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType21Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "FRST") )]
	CodeFRST,
}

impl AssetClassSubProductType21Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType22Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType22Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "LSTK") )]
	CodeLSTK,
}

impl AssetClassSubProductType22Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType23Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType23Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "SEAF") )]
	CodeSEAF,
}

impl AssetClassSubProductType23Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType24Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType24Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "COAL") )]
	CodeCOAL,
}

impl AssetClassSubProductType24Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType25Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType25Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "DIST") )]
	CodeDIST,
}

impl AssetClassSubProductType25Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType26Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType26Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "INRG") )]
	CodeINRG,
}

impl AssetClassSubProductType26Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType27Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType27Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "LGHT") )]
	CodeLGHT,
}

impl AssetClassSubProductType27Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType28Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType28Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "RNNG") )]
	CodeRNNG,
}

impl AssetClassSubProductType28Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType29Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType29Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CRBR") )]
	CodeCRBR,
}

impl AssetClassSubProductType29Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "SOFT") )]
	CodeSOFT,
}

impl AssetClassSubProductType2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType30Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType30Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "WTHR") )]
	CodeWTHR,
}

impl AssetClassSubProductType30Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType31Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType31Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "DRYF") )]
	CodeDRYF,
}

impl AssetClassSubProductType31Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType32Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType32Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "WETF") )]
	CodeWETF,
}

impl AssetClassSubProductType32Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType33Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType33Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CSTR") )]
	CodeCSTR,
}

impl AssetClassSubProductType33Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType34Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType34Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "MFTG") )]
	CodeMFTG,
}

impl AssetClassSubProductType34Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType35Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType35Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CBRD") )]
	CodeCBRD,
}

impl AssetClassSubProductType35Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType36Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType36Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "NSPT") )]
	CodeNSPT,
}

impl AssetClassSubProductType36Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType37Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType37Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "PULP") )]
	CodePULP,
}

impl AssetClassSubProductType37Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType38Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType38Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "RCVP") )]
	CodeRCVP,
}

impl AssetClassSubProductType38Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType39Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType39Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "AMMO") )]
	CodeAMMO,
}

impl AssetClassSubProductType39Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "OOLI") )]
	CodeOOLI,
}

impl AssetClassSubProductType3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType40Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType40Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "DAPH") )]
	CodeDAPH,
}

impl AssetClassSubProductType40Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType41Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType41Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "PTSH") )]
	CodePTSH,
}

impl AssetClassSubProductType41Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType42Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType42Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "SLPH") )]
	CodeSLPH,
}

impl AssetClassSubProductType42Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType43Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType43Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "UREA") )]
	CodeUREA,
}

impl AssetClassSubProductType43Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType44Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType44Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "UAAN") )]
	CodeUAAN,
}

impl AssetClassSubProductType44Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType45Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType45Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "POTA") )]
	CodePOTA,
}

impl AssetClassSubProductType45Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType46Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType46Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CSHP") )]
	CodeCSHP,
}

impl AssetClassSubProductType46Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType47Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType47Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "DLVR") )]
	CodeDLVR,
}

impl AssetClassSubProductType47Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType48Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType48Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "NDLV") )]
	CodeNDLV,
}

impl AssetClassSubProductType48Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType49Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType49Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
}

impl AssetClassSubProductType49Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType50Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType50Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RCVP") )]
	CodeRCVP,
}

impl AssetClassSubProductType50Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType5Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType5Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "GRIN") )]
	CodeGRIN,
}

impl AssetClassSubProductType5Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType6Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType6Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ELEC") )]
	CodeELEC,
}

impl AssetClassSubProductType6Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType7Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType7Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "NGAS") )]
	CodeNGAS,
}

impl AssetClassSubProductType7Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassSubProductType8Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassSubProductType8Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "OILP") )]
	CodeOILP,
}

impl AssetClassSubProductType8Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetClassTransactionType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetClassTransactionType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CRCK") )]
	CodeCRCK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DIFF") )]
	CodeDIFF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FUTR") )]
	CodeFUTR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MINI") )]
	CodeMINI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OPTN") )]
	CodeOPTN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTCT") )]
	CodeOTCT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ORIT") )]
	CodeORIT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SWAP") )]
	CodeSWAP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TAPO") )]
	CodeTAPO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
}

impl AssetClassTransactionType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetFXSubProductType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetFXSubProductType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "FXCR") )]
	CodeFXCR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FXEM") )]
	CodeFXEM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FXMJ") )]
	CodeFXMJ,
}

impl AssetFXSubProductType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssetHolding1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetHolding1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstHrcutVal") )]
	pub pst_hrcut_val: ActiveCurrencyAnd24Amount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AsstTp") )]
	pub asst_tp: AssetHolding1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollRqrmnt") )]
	pub coll_rqrmnt: CollateralAccountType3Code,
}

impl AssetHolding1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pst_hrcut_val.validate()?;
		self.asst_tp.validate()?;
		self.coll_rqrmnt.validate()?;
		Ok(())
	}
}


// AssetHolding1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetHolding1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Gold", skip_serializing_if = "Option::is_none") )]
	pub gold: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Trpty", skip_serializing_if = "Option::is_none") )]
	pub trpty: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Csh", skip_serializing_if = "Option::is_none") )]
	pub csh: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Scty", skip_serializing_if = "Option::is_none") )]
	pub scty: Option<SecurityIdentificationAndAmount1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Grnt", skip_serializing_if = "Option::is_none") )]
	pub grnt: Option<Guarantee1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cmmdty", skip_serializing_if = "Option::is_none") )]
	pub cmmdty: Option<Commodity2>,
}

impl AssetHolding1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.gold { val.validate()? }
		if let Some(ref val) = self.trpty { val.validate()? }
		if let Some(ref val) = self.csh { val.validate()? }
		if let Some(ref val) = self.scty { val.validate()? }
		if let Some(ref val) = self.grnt { val.validate()? }
		if let Some(ref val) = self.cmmdty { val.validate()? }
		Ok(())
	}
}


// AssetHolding3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetHolding3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstHrcutVal") )]
	pub pst_hrcut_val: ActiveCurrencyAnd24Amount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AsstTp") )]
	pub asst_tp: AssetHolding3Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollRqrmnt") )]
	pub coll_rqrmnt: CollateralAccountType3Code,
}

impl AssetHolding3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pst_hrcut_val.validate()?;
		self.asst_tp.validate()?;
		self.coll_rqrmnt.validate()?;
		Ok(())
	}
}


// AssetHolding3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssetHolding3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Gold", skip_serializing_if = "Option::is_none") )]
	pub gold: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Trpty", skip_serializing_if = "Option::is_none") )]
	pub trpty: Option<TripartyCollateralAndAmount1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Csh", skip_serializing_if = "Option::is_none") )]
	pub csh: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Scty", skip_serializing_if = "Option::is_none") )]
	pub scty: Option<SecurityIdentificationAndAmount1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Grnt", skip_serializing_if = "Option::is_none") )]
	pub grnt: Option<Guarantee1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cmmdty", skip_serializing_if = "Option::is_none") )]
	pub cmmdty: Option<Commodity2>,
}

impl AssetHolding3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.gold { val.validate()? }
		if let Some(ref val) = self.trpty { val.validate()? }
		if let Some(ref val) = self.csh { val.validate()? }
		if let Some(ref val) = self.scty { val.validate()? }
		if let Some(ref val) = self.grnt { val.validate()? }
		if let Some(ref val) = self.cmmdty { val.validate()? }
		Ok(())
	}
}


// AssetPriceType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssetPriceType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ARGM") )]
	CodeARGM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BLTC") )]
	CodeBLTC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EXOF") )]
	CodeEXOF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GBCL") )]
	CodeGBCL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IHSM") )]
	CodeIHSM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PLAT") )]
	CodePLAT,
}

impl AssetPriceType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssignmentMethod1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AssignmentMethod1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "RAND") )]
	CodeRAND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PROR") )]
	CodePROR,
}

impl AssignmentMethod1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AssignmentMethod2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AssignmentMethod2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<AssignmentMethod1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl AssignmentMethod2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// AttendanceContext1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AttendanceContext1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ATTD") )]
	CodeATTD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SATT") )]
	CodeSATT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UATT") )]
	CodeUATT,
}

impl AttendanceContext1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AuctionData2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AuctionData2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgPhs", skip_serializing_if = "Option::is_none") )]
	pub tradg_phs: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IndctvAuctnPric", skip_serializing_if = "Option::is_none") )]
	pub indctv_auctn_pric: Option<SecuritiesTransactionPrice21Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IndctvAuctnVol", skip_serializing_if = "Option::is_none") )]
	pub indctv_auctn_vol: Option<FinancialInstrumentQuantity25Choice>,
}

impl AuctionData2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tradg_phs {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tradg_phs is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 50 {
				return Err(ValidationError::new(1002, "tradg_phs exceeds the maximum length of 50".to_string()));
			}
		}
		if let Some(ref val) = self.indctv_auctn_pric { val.validate()? }
		if let Some(ref val) = self.indctv_auctn_vol { val.validate()? }
		Ok(())
	}
}


// AuditTrail1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AuditTrail1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FldNm") )]
	pub fld_nm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OdFldVal") )]
	pub od_fld_val: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NewFldVal") )]
	pub new_fld_val: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OprTmStmp") )]
	pub opr_tm_stmp: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstgUsr") )]
	pub instg_usr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ApprvgUsr", skip_serializing_if = "Option::is_none") )]
	pub apprvg_usr: Option<String>,
}

impl AuditTrail1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.fld_nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "fld_nm is shorter than the minimum length of 1".to_string()));
		}
		if self.fld_nm.chars().count() > 35 {
			return Err(ValidationError::new(1002, "fld_nm exceeds the maximum length of 35".to_string()));
		}
		if self.od_fld_val.chars().count() < 1 {
			return Err(ValidationError::new(1001, "od_fld_val is shorter than the minimum length of 1".to_string()));
		}
		if self.od_fld_val.chars().count() > 350 {
			return Err(ValidationError::new(1002, "od_fld_val exceeds the maximum length of 350".to_string()));
		}
		if self.new_fld_val.chars().count() < 1 {
			return Err(ValidationError::new(1001, "new_fld_val is shorter than the minimum length of 1".to_string()));
		}
		if self.new_fld_val.chars().count() > 350 {
			return Err(ValidationError::new(1002, "new_fld_val exceeds the maximum length of 350".to_string()));
		}
		if self.instg_usr.chars().count() < 1 {
			return Err(ValidationError::new(1001, "instg_usr is shorter than the minimum length of 1".to_string()));
		}
		if self.instg_usr.chars().count() > 256 {
			return Err(ValidationError::new(1002, "instg_usr exceeds the maximum length of 256".to_string()));
		}
		if let Some(ref val) = self.apprvg_usr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "apprvg_usr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 256 {
				return Err(ValidationError::new(1002, "apprvg_usr exceeds the maximum length of 256".to_string()));
			}
		}
		Ok(())
	}
}


// AuditTrailOrBusinessError6Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AuditTrailOrBusinessError6Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AudtTrl", skip_serializing_if = "Option::is_none") )]
	pub audt_trl: Option<Vec<AuditTrail1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizErr", skip_serializing_if = "Option::is_none") )]
	pub biz_err: Option<Vec<ErrorHandling5>>,
}

impl AuditTrailOrBusinessError6Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.audt_trl { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.biz_err { for item in vec { item.validate()? } }
		Ok(())
	}
}


// AuthenticationChannel1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AuthenticationChannel1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl AuthenticationChannel1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// AuthenticationEntity1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AuthenticationEntity1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ICCD") )]
	CodeICCD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AGNT") )]
	CodeAGNT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MERC") )]
	CodeMERC,
}

impl AuthenticationEntity1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// AuthenticationMethod1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum AuthenticationMethod1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "UKNW") )]
	CodeUKNW,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BYPS") )]
	CodeBYPS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NPIN") )]
	CodeNPIN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FPIN") )]
	CodeFPIN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CPSG") )]
	CodeCPSG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PPSG") )]
	CodePPSG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MANU") )]
	CodeMANU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MERC") )]
	CodeMERC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SCRT") )]
	CodeSCRT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SNCT") )]
	CodeSNCT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SCNL") )]
	CodeSCNL,
}

impl AuthenticationMethod1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Authorisation1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Authorisation1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<Authorisation1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl Authorisation1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 128 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 128".to_string()));
			}
		}
		Ok(())
	}
}


// Authorisation1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum Authorisation1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "AUTH") )]
	CodeAUTH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FDET") )]
	CodeFDET,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FSUM") )]
	CodeFSUM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ILEV") )]
	CodeILEV,
}

impl Authorisation1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Authorisation2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Authorisation2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MaxAmtByTx", skip_serializing_if = "Option::is_none") )]
	pub max_amt_by_tx: Option<FixedAmountOrUnlimited1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MaxAmtByPrd", skip_serializing_if = "Option::is_none") )]
	pub max_amt_by_prd: Option<Vec<MaximumAmountByPeriod1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MaxAmtByBlkSubmissn", skip_serializing_if = "Option::is_none") )]
	pub max_amt_by_blk_submissn: Option<FixedAmountOrUnlimited1Choice>,
}

impl Authorisation2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.max_amt_by_tx { val.validate()? }
		if let Some(ref vec) = self.max_amt_by_prd { for item in vec { item.validate()? } }
		if let Some(ref val) = self.max_amt_by_blk_submissn { val.validate()? }
		Ok(())
	}
}


// AuthorityInvestigation2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AuthorityInvestigation2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: AuthorityRequestType1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstgtdRoles") )]
	pub invstgtd_roles: InvestigatedParties1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInvstgtdPties", skip_serializing_if = "Option::is_none") )]
	pub addtl_invstgtd_pties: Option<InvestigatedParties1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
}

impl AuthorityInvestigation2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tp.validate()?;
		self.invstgtd_roles.validate()?;
		if let Some(ref val) = self.addtl_invstgtd_pties { val.validate()? }
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 500 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 500".to_string()));
			}
		}
		Ok(())
	}
}


// AuthorityRequestType1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AuthorityRequestType1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgNmId") )]
	pub msg_nm_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgNm", skip_serializing_if = "Option::is_none") )]
	pub msg_nm: Option<String>,
}

impl AuthorityRequestType1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_nm_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_nm_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_nm_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_nm_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.msg_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "msg_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "msg_nm exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// AvailableFinancialResourcesAmount1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct AvailableFinancialResourcesAmount1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlInitlMrgn") )]
	pub ttl_initl_mrgn: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlPrfnddDfltFnd") )]
	pub ttl_prfndd_dflt_fnd: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CCPSkinInTheGame") )]
	pub ccp_skin_in_the_game: Vec<ReportingAssetBreakdown1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrDfltFndCntrbtn") )]
	pub othr_dflt_fnd_cntrbtn: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UfnddMmbCmmtmnt") )]
	pub ufndd_mmb_cmmtmnt: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UfnddThrdPtyCmmtmnt") )]
	pub ufndd_thrd_pty_cmmtmnt: ActiveCurrencyAndAmount,
}

impl AvailableFinancialResourcesAmount1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.ttl_initl_mrgn.validate()?;
		self.ttl_prfndd_dflt_fnd.validate()?;
		for item in &self.ccp_skin_in_the_game { item.validate()? }
		self.othr_dflt_fnd_cntrbtn.validate()?;
		self.ufndd_mmb_cmmtmnt.validate()?;
		self.ufndd_thrd_pty_cmmtmnt.validate()?;
		Ok(())
	}
}


// BackTestingMethodology1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BackTestingMethodology1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RskMdlTp") )]
	pub rsk_mdl_tp: ModelType1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MdlCnfdncLvl") )]
	pub mdl_cnfdnc_lvl: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VartnMrgnCleanInd") )]
	pub vartn_mrgn_clean_ind: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Desc", skip_serializing_if = "Option::is_none") )]
	pub desc: Option<String>,
}

impl BackTestingMethodology1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.rsk_mdl_tp.validate()?;
		if let Some(ref val) = self.desc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "desc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 2000 {
				return Err(ValidationError::new(1002, "desc exceeds the maximum length of 2000".to_string()));
			}
		}
		Ok(())
	}
}


// BalanceAdjustment1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BalanceAdjustment1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: BalanceAdjustmentType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Desc") )]
	pub desc: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BalAmt") )]
	pub bal_amt: AmountAndDirection34,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AvrgAmt", skip_serializing_if = "Option::is_none") )]
	pub avrg_amt: Option<AmountAndDirection34>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ErrDt", skip_serializing_if = "Option::is_none") )]
	pub err_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstngDt") )]
	pub pstng_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Days", skip_serializing_if = "Option::is_none") )]
	pub days: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EarngsAdjstmntAmt", skip_serializing_if = "Option::is_none") )]
	pub earngs_adjstmnt_amt: Option<AmountAndDirection34>,
}

impl BalanceAdjustment1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tp.validate()?;
		if self.desc.chars().count() < 1 {
			return Err(ValidationError::new(1001, "desc is shorter than the minimum length of 1".to_string()));
		}
		if self.desc.chars().count() > 105 {
			return Err(ValidationError::new(1002, "desc exceeds the maximum length of 105".to_string()));
		}
		self.bal_amt.validate()?;
		if let Some(ref val) = self.avrg_amt { val.validate()? }
		if let Some(ref val) = self.earngs_adjstmnt_amt { val.validate()? }
		Ok(())
	}
}


// BalanceAdjustmentType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum BalanceAdjustmentType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "LDGR") )]
	CodeLDGR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FLOT") )]
	CodeFLOT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CLLD") )]
	CodeCLLD,
}

impl BalanceAdjustmentType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// BalanceCounterparty1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum BalanceCounterparty1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "BILA") )]
	CodeBILA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MULT") )]
	CodeMULT,
}

impl BalanceCounterparty1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// BalanceRestrictionType1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BalanceRestrictionType1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: GenericIdentification1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Desc", skip_serializing_if = "Option::is_none") )]
	pub desc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrcgTp", skip_serializing_if = "Option::is_none") )]
	pub prcg_tp: Option<ProcessingType1Choice>,
}

impl BalanceRestrictionType1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tp.validate()?;
		if let Some(ref val) = self.desc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "desc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "desc exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.prcg_tp { val.validate()? }
		Ok(())
	}
}


// BalanceStatus1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum BalanceStatus1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "PDNG") )]
	CodePDNG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "STLD") )]
	CodeSTLD,
}

impl BalanceStatus1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// BalanceStatus2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BalanceStatus2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Bal") )]
	pub bal: ActiveCurrencyAndAmount,
}

impl BalanceStatus2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.bal.validate()?;
		Ok(())
	}
}


// BalanceSubType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BalanceSubType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl BalanceSubType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// BalanceTransfer5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BalanceTransfer5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BalTrfRef", skip_serializing_if = "Option::is_none") )]
	pub bal_trf_ref: Option<BalanceTransferReference1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BalTrfMtd", skip_serializing_if = "Option::is_none") )]
	pub bal_trf_mtd: Option<SettlementMethod5Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BalTrfFndgLmt", skip_serializing_if = "Option::is_none") )]
	pub bal_trf_fndg_lmt: Option<BalanceTransferFundingLimit1>,
}

impl BalanceTransfer5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.bal_trf_ref { val.validate()? }
		if let Some(ref val) = self.bal_trf_mtd { val.validate()? }
		if let Some(ref val) = self.bal_trf_fndg_lmt { val.validate()? }
		Ok(())
	}
}


// BalanceTransferFundingLimit1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BalanceTransferFundingLimit1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CcyAmt") )]
	pub ccy_amt: ActiveCurrencyAndAmount,
}

impl BalanceTransferFundingLimit1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.ccy_amt.validate()?;
		Ok(())
	}
}


// BalanceTransferReference1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BalanceTransferReference1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BalTrfRef") )]
	pub bal_trf_ref: String,
}

impl BalanceTransferReference1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.bal_trf_ref.chars().count() < 1 {
			return Err(ValidationError::new(1001, "bal_trf_ref is shorter than the minimum length of 1".to_string()));
		}
		if self.bal_trf_ref.chars().count() > 35 {
			return Err(ValidationError::new(1002, "bal_trf_ref exceeds the maximum length of 35".to_string()));
		}
		Ok(())
	}
}


// BalanceTransferWindow1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum BalanceTransferWindow1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "DAYH") )]
	CodeDAYH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EARL") )]
	CodeEARL,
}

impl BalanceTransferWindow1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// BalanceType10Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BalanceType10Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl BalanceType10Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// BalanceType11Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BalanceType11Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl BalanceType11Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// BalanceType13 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BalanceType13 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdOrPrtry") )]
	pub cd_or_prtry: BalanceType10Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubTp", skip_serializing_if = "Option::is_none") )]
	pub sub_tp: Option<BalanceSubType1Choice>,
}

impl BalanceType13 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.cd_or_prtry.validate()?;
		if let Some(ref val) = self.sub_tp { val.validate()? }
		Ok(())
	}
}


// BalanceType9Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BalanceType9Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<SystemBalanceType2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl BalanceType9Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// BankTransactionCodeStructure4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BankTransactionCodeStructure4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Domn", skip_serializing_if = "Option::is_none") )]
	pub domn: Option<BankTransactionCodeStructure5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<ProprietaryBankTransactionCodeStructure1>,
}

impl BankTransactionCodeStructure4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.domn { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// BankTransactionCodeStructure5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BankTransactionCodeStructure5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd") )]
	pub cd: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Fmly") )]
	pub fmly: BankTransactionCodeStructure6,
}

impl BankTransactionCodeStructure5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.cd.chars().count() < 1 {
			return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
		}
		if self.cd.chars().count() > 4 {
			return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
		}
		self.fmly.validate()?;
		Ok(())
	}
}


// BankTransactionCodeStructure6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BankTransactionCodeStructure6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd") )]
	pub cd: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubFmlyCd") )]
	pub sub_fmly_cd: String,
}

impl BankTransactionCodeStructure6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.cd.chars().count() < 1 {
			return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
		}
		if self.cd.chars().count() > 4 {
			return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
		}
		if self.sub_fmly_cd.chars().count() < 1 {
			return Err(ValidationError::new(1001, "sub_fmly_cd is shorter than the minimum length of 1".to_string()));
		}
		if self.sub_fmly_cd.chars().count() > 4 {
			return Err(ValidationError::new(1002, "sub_fmly_cd exceeds the maximum length of 4".to_string()));
		}
		Ok(())
	}
}


// BasketConstituents3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BasketConstituents3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrmId") )]
	pub instrm_id: InstrumentIdentification6Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Qty", skip_serializing_if = "Option::is_none") )]
	pub qty: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnitOfMeasr", skip_serializing_if = "Option::is_none") )]
	pub unit_of_measr: Option<UnitOfMeasure8Choice>,
}

impl BasketConstituents3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.instrm_id.validate()?;
		if let Some(ref val) = self.unit_of_measr { val.validate()? }
		Ok(())
	}
}


// BasketDescription3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BasketDescription3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISIN", skip_serializing_if = "Option::is_none") )]
	pub isin: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Indx", skip_serializing_if = "Option::is_none") )]
	pub indx: Option<Vec<FinancialInstrument58>>,
}

impl BasketDescription3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.isin {
			for item in vec {
				let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
				if !pattern.is_match(&item) {
					return Err(ValidationError::new(1005, "isin does not match the required pattern".to_string()));
				}
			}
		}
		if let Some(ref vec) = self.indx { for item in vec { item.validate()? } }
		Ok(())
	}
}


// BasketQuery1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BasketQuery1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Strr", skip_serializing_if = "Option::is_none") )]
	pub strr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Idr", skip_serializing_if = "Option::is_none") )]
	pub idr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISIN", skip_serializing_if = "Option::is_none") )]
	pub isin: Option<String>,
}

impl BasketQuery1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.strr {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "strr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.idr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "idr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 52 {
				return Err(ValidationError::new(1002, "idr exceeds the maximum length of 52".to_string()));
			}
		}
		if let Some(ref val) = self.isin {
			let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "isin does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// BatchInformation2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BatchInformation2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId", skip_serializing_if = "Option::is_none") )]
	pub msg_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtInfId", skip_serializing_if = "Option::is_none") )]
	pub pmt_inf_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfTxs", skip_serializing_if = "Option::is_none") )]
	pub nb_of_txs: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlAmt", skip_serializing_if = "Option::is_none") )]
	pub ttl_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbtInd", skip_serializing_if = "Option::is_none") )]
	pub cdt_dbt_ind: Option<CreditDebitCode>,
}

impl BatchInformation2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.msg_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.pmt_inf_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pmt_inf_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "pmt_inf_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.nb_of_txs {
			let pattern = Regex::new("[0-9]{1,15}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "nb_of_txs does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.ttl_amt { val.validate()? }
		if let Some(ref val) = self.cdt_dbt_ind { val.validate()? }
		Ok(())
	}
}


// BenchmarkCancellation1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BenchmarkCancellation1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechRcrdId", skip_serializing_if = "Option::is_none") )]
	pub tech_rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: SecurityIdentification19,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl BenchmarkCancellation1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tech_rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tech_rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tech_rcrd_id exceeds the maximum length of 35".to_string()));
			}
		}
		self.id.validate()?;
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// BenchmarkCreate1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BenchmarkCreate1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechRcrdId", skip_serializing_if = "Option::is_none") )]
	pub tech_rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: SecurityIdentification19,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr") )]
	pub othr: BenchmarkDetail1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Admstr") )]
	pub admstr: PartyIdentification136,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NdrsngPty", skip_serializing_if = "Option::is_none") )]
	pub ndrsng_pty: Option<PartyIdentification136>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts", skip_serializing_if = "Option::is_none") )]
	pub sts: Option<StatusDetail1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechVldtyPrd", skip_serializing_if = "Option::is_none") )]
	pub tech_vldty_prd: Option<Period4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl BenchmarkCreate1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tech_rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tech_rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tech_rcrd_id exceeds the maximum length of 35".to_string()));
			}
		}
		self.id.validate()?;
		self.othr.validate()?;
		self.admstr.validate()?;
		if let Some(ref val) = self.ndrsng_pty { val.validate()? }
		if let Some(ref val) = self.sts { val.validate()? }
		if let Some(ref val) = self.tech_vldty_prd { val.validate()? }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// BenchmarkCurve6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BenchmarkCurve6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sprd", skip_serializing_if = "Option::is_none") )]
	pub sprd: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BchmkId", skip_serializing_if = "Option::is_none") )]
	pub bchmk_id: Option<SecurityIdentification39>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BchmkPric", skip_serializing_if = "Option::is_none") )]
	pub bchmk_pric: Option<Price8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BchmkCrvCcy", skip_serializing_if = "Option::is_none") )]
	pub bchmk_crv_ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BchmkCrvNm", skip_serializing_if = "Option::is_none") )]
	pub bchmk_crv_nm: Option<BenchmarkCurveName7Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BchmkCrvPt", skip_serializing_if = "Option::is_none") )]
	pub bchmk_crv_pt: Option<String>,
}

impl BenchmarkCurve6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.bchmk_id { val.validate()? }
		if let Some(ref val) = self.bchmk_pric { val.validate()? }
		if let Some(ref val) = self.bchmk_crv_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "bchmk_crv_ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.bchmk_crv_nm { val.validate()? }
		if let Some(ref val) = self.bchmk_crv_pt {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "bchmk_crv_pt is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 256 {
				return Err(ValidationError::new(1002, "bchmk_crv_pt exceeds the maximum length of 256".to_string()));
			}
		}
		Ok(())
	}
}


// BenchmarkCurveName10Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BenchmarkCurveName10Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Indx", skip_serializing_if = "Option::is_none") )]
	pub indx: Option<BenchmarkCurveName3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
}

impl BenchmarkCurveName10Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.indx { val.validate()? }
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 350".to_string()));
			}
		}
		Ok(())
	}
}


// BenchmarkCurveName1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum BenchmarkCurveName1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "MAAA") )]
	CodeMAAA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FUSW") )]
	CodeFUSW,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LIBI") )]
	CodeLIBI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LIBO") )]
	CodeLIBO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SWAP") )]
	CodeSWAP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TREA") )]
	CodeTREA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EURI") )]
	CodeEURI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PFAN") )]
	CodePFAN,
}

impl BenchmarkCurveName1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// BenchmarkCurveName2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum BenchmarkCurveName2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "WIBO") )]
	CodeWIBO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TREA") )]
	CodeTREA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TIBO") )]
	CodeTIBO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TLBO") )]
	CodeTLBO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SWAP") )]
	CodeSWAP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "STBO") )]
	CodeSTBO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRBO") )]
	CodePRBO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PFAN") )]
	CodePFAN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NIBO") )]
	CodeNIBO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MAAA") )]
	CodeMAAA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MOSP") )]
	CodeMOSP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LIBO") )]
	CodeLIBO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LIBI") )]
	CodeLIBI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "JIBA") )]
	CodeJIBA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISDA") )]
	CodeISDA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GCFR") )]
	CodeGCFR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FUSW") )]
	CodeFUSW,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EUCH") )]
	CodeEUCH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EUUS") )]
	CodeEUUS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EURI") )]
	CodeEURI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EONS") )]
	CodeEONS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EONA") )]
	CodeEONA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CIBO") )]
	CodeCIBO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CDOR") )]
	CodeCDOR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BUBO") )]
	CodeBUBO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BBSW") )]
	CodeBBSW,
}

impl BenchmarkCurveName2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// BenchmarkCurveName3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum BenchmarkCurveName3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ESTR") )]
	CodeESTR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BBSW") )]
	CodeBBSW,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BUBO") )]
	CodeBUBO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CDOR") )]
	CodeCDOR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CIBO") )]
	CodeCIBO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EONA") )]
	CodeEONA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EONS") )]
	CodeEONS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EURI") )]
	CodeEURI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EUUS") )]
	CodeEUUS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EUCH") )]
	CodeEUCH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FUSW") )]
	CodeFUSW,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GCFR") )]
	CodeGCFR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISDA") )]
	CodeISDA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "JIBA") )]
	CodeJIBA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LIBI") )]
	CodeLIBI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LIBO") )]
	CodeLIBO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MOSP") )]
	CodeMOSP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MAAA") )]
	CodeMAAA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NIBO") )]
	CodeNIBO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PFAN") )]
	CodePFAN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRBO") )]
	CodePRBO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "STBO") )]
	CodeSTBO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SWAP") )]
	CodeSWAP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TLBO") )]
	CodeTLBO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TIBO") )]
	CodeTIBO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TREA") )]
	CodeTREA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WIBO") )]
	CodeWIBO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SOFR") )]
	CodeSOFR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SONA") )]
	CodeSONA,
}

impl BenchmarkCurveName3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// BenchmarkCurveName4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BenchmarkCurveName4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISIN", skip_serializing_if = "Option::is_none") )]
	pub isin: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Indx", skip_serializing_if = "Option::is_none") )]
	pub indx: Option<BenchmarkCurveName2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
}

impl BenchmarkCurveName4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.isin {
			let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "isin does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.indx { val.validate()? }
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 25 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 25".to_string()));
			}
		}
		Ok(())
	}
}


// BenchmarkCurveName5Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BenchmarkCurveName5Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Indx", skip_serializing_if = "Option::is_none") )]
	pub indx: Option<BenchmarkCurveName2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
}

impl BenchmarkCurveName5Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.indx { val.validate()? }
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 25 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 25".to_string()));
			}
		}
		Ok(())
	}
}


// BenchmarkCurveName6Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BenchmarkCurveName6Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISIN", skip_serializing_if = "Option::is_none") )]
	pub isin: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Indx", skip_serializing_if = "Option::is_none") )]
	pub indx: Option<BenchmarkCurveName2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
}

impl BenchmarkCurveName6Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.isin {
			let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "isin does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.indx { val.validate()? }
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 25 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 25".to_string()));
			}
		}
		Ok(())
	}
}


// BenchmarkCurveName7Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BenchmarkCurveName7Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<BenchmarkCurveName1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl BenchmarkCurveName7Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// BenchmarkDetail1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BenchmarkDetail1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FullNm") )]
	pub full_nm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Indx", skip_serializing_if = "Option::is_none") )]
	pub indx: Option<BenchmarkCurveName2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cmnt", skip_serializing_if = "Option::is_none") )]
	pub cmnt: Option<String>,
}

impl BenchmarkDetail1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.full_nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "full_nm is shorter than the minimum length of 1".to_string()));
		}
		if self.full_nm.chars().count() > 350 {
			return Err(ValidationError::new(1002, "full_nm exceeds the maximum length of 350".to_string()));
		}
		if let Some(ref val) = self.indx { val.validate()? }
		if let Some(ref val) = self.cmnt {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cmnt is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 20000 {
				return Err(ValidationError::new(1002, "cmnt exceeds the maximum length of 20000".to_string()));
			}
		}
		Ok(())
	}
}


// BenchmarkReport1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BenchmarkReport1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cret", skip_serializing_if = "Option::is_none") )]
	pub cret: Option<BenchmarkCreate1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Upd", skip_serializing_if = "Option::is_none") )]
	pub upd: Option<BenchmarkUpdate1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cxl", skip_serializing_if = "Option::is_none") )]
	pub cxl: Option<BenchmarkCancellation1>,
}

impl BenchmarkReport1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cret { val.validate()? }
		if let Some(ref val) = self.upd { val.validate()? }
		if let Some(ref val) = self.cxl { val.validate()? }
		Ok(())
	}
}


// BenchmarkUpdate1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BenchmarkUpdate1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechRcrdId", skip_serializing_if = "Option::is_none") )]
	pub tech_rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: SecurityIdentification19,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsId", skip_serializing_if = "Option::is_none") )]
	pub prvs_id: Option<SecurityIdentification19>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr") )]
	pub othr: BenchmarkDetail1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Admstr") )]
	pub admstr: PartyIdentification136,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NdrsngPty", skip_serializing_if = "Option::is_none") )]
	pub ndrsng_pty: Option<PartyIdentification136>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts", skip_serializing_if = "Option::is_none") )]
	pub sts: Option<StatusDetail1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechVldtyPrd", skip_serializing_if = "Option::is_none") )]
	pub tech_vldty_prd: Option<Period4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl BenchmarkUpdate1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tech_rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tech_rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tech_rcrd_id exceeds the maximum length of 35".to_string()));
			}
		}
		self.id.validate()?;
		if let Some(ref val) = self.prvs_id { val.validate()? }
		self.othr.validate()?;
		self.admstr.validate()?;
		if let Some(ref val) = self.ndrsng_pty { val.validate()? }
		if let Some(ref val) = self.sts { val.validate()? }
		if let Some(ref val) = self.tech_vldty_prd { val.validate()? }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// BilateralLimit4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BilateralLimit4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtyId") )]
	pub ctr_pty_id: BranchAndFinancialInstitutionIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LmtAmt") )]
	pub lmt_amt: Amount2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbtInd") )]
	pub cdt_dbt_ind: CreditDebitCode,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BilBal", skip_serializing_if = "Option::is_none") )]
	pub bil_bal: Option<Vec<CashBalance11>>,
}

impl BilateralLimit4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.ctr_pty_id.validate()?;
		self.lmt_amt.validate()?;
		self.cdt_dbt_ind.validate()?;
		if let Some(ref vec) = self.bil_bal { for item in vec { item.validate()? } }
		Ok(())
	}
}


// BillingBalance1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BillingBalance1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: BillingBalanceType1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val") )]
	pub val: AmountAndDirection34,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CcyTp", skip_serializing_if = "Option::is_none") )]
	pub ccy_tp: Option<BillingCurrencyType1Code>,
}

impl BillingBalance1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tp.validate()?;
		self.val.validate()?;
		if let Some(ref val) = self.ccy_tp { val.validate()? }
		Ok(())
	}
}


// BillingBalanceType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BillingBalanceType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl BillingBalanceType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// BillingChargeMethod1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum BillingChargeMethod1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "UPRC") )]
	CodeUPRC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "STAM") )]
	CodeSTAM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BCHG") )]
	CodeBCHG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DPRC") )]
	CodeDPRC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FCHG") )]
	CodeFCHG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LPRC") )]
	CodeLPRC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MCHG") )]
	CodeMCHG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MXRD") )]
	CodeMXRD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TIR1") )]
	CodeTIR1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TIR2") )]
	CodeTIR2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TIR3") )]
	CodeTIR3,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TIR4") )]
	CodeTIR4,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TIR5") )]
	CodeTIR5,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TIR6") )]
	CodeTIR6,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TIR7") )]
	CodeTIR7,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TIR8") )]
	CodeTIR8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TIR9") )]
	CodeTIR9,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TPRC") )]
	CodeTPRC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ZPRC") )]
	CodeZPRC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BBSE") )]
	CodeBBSE,
}

impl BillingChargeMethod1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// BillingCompensation1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BillingCompensation1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: BillingCompensationType1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val") )]
	pub val: AmountAndDirection34,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CcyTp", skip_serializing_if = "Option::is_none") )]
	pub ccy_tp: Option<BillingCurrencyType2Code>,
}

impl BillingCompensation1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tp.validate()?;
		self.val.validate()?;
		if let Some(ref val) = self.ccy_tp { val.validate()? }
		Ok(())
	}
}


// BillingCompensationType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BillingCompensationType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl BillingCompensationType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// BillingCurrencyType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum BillingCurrencyType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACCT") )]
	CodeACCT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "STLM") )]
	CodeSTLM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRCG") )]
	CodePRCG,
}

impl BillingCurrencyType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// BillingCurrencyType2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum BillingCurrencyType2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACCT") )]
	CodeACCT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "STLM") )]
	CodeSTLM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRCG") )]
	CodePRCG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HOST") )]
	CodeHOST,
}

impl BillingCurrencyType2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// BillingMethod1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BillingMethod1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SvcChrgHstAmt") )]
	pub svc_chrg_hst_amt: AmountAndDirection34,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SvcTax") )]
	pub svc_tax: BillingServicesAmount1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlChrg") )]
	pub ttl_chrg: BillingServicesAmount2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxId") )]
	pub tax_id: Vec<BillingServicesTax1>,
}

impl BillingMethod1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.svc_chrg_hst_amt.validate()?;
		self.svc_tax.validate()?;
		self.ttl_chrg.validate()?;
		for item in &self.tax_id { item.validate()? }
		Ok(())
	}
}


// BillingMethod1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BillingMethod1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MtdA", skip_serializing_if = "Option::is_none") )]
	pub mtd_a: Option<BillingMethod1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MtdB", skip_serializing_if = "Option::is_none") )]
	pub mtd_b: Option<BillingMethod2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MtdD", skip_serializing_if = "Option::is_none") )]
	pub mtd_d: Option<BillingMethod3>,
}

impl BillingMethod1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mtd_a { val.validate()? }
		if let Some(ref val) = self.mtd_b { val.validate()? }
		if let Some(ref val) = self.mtd_d { val.validate()? }
		Ok(())
	}
}


// BillingMethod2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BillingMethod2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SvcChrgHstAmt") )]
	pub svc_chrg_hst_amt: AmountAndDirection34,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SvcTax") )]
	pub svc_tax: BillingServicesAmount1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxId") )]
	pub tax_id: Vec<BillingServicesTax1>,
}

impl BillingMethod2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.svc_chrg_hst_amt.validate()?;
		self.svc_tax.validate()?;
		for item in &self.tax_id { item.validate()? }
		Ok(())
	}
}


// BillingMethod3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BillingMethod3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SvcTaxPricAmt") )]
	pub svc_tax_pric_amt: AmountAndDirection34,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxId") )]
	pub tax_id: Vec<BillingServicesTax2>,
}

impl BillingMethod3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.svc_tax_pric_amt.validate()?;
		for item in &self.tax_id { item.validate()? }
		Ok(())
	}
}


// BillingMethod4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BillingMethod4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SvcDtl") )]
	pub svc_dtl: Vec<BillingServiceParameters2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxClctn") )]
	pub tax_clctn: TaxCalculation1,
}

impl BillingMethod4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		for item in &self.svc_dtl { item.validate()? }
		self.tax_clctn.validate()?;
		Ok(())
	}
}


// BillingPrice1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BillingPrice1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ccy", skip_serializing_if = "Option::is_none") )]
	pub ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnitPric", skip_serializing_if = "Option::is_none") )]
	pub unit_pric: Option<AmountAndDirection34>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mtd", skip_serializing_if = "Option::is_none") )]
	pub mtd: Option<BillingChargeMethod1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rule", skip_serializing_if = "Option::is_none") )]
	pub rule: Option<String>,
}

impl BillingPrice1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.unit_pric { val.validate()? }
		if let Some(ref val) = self.mtd { val.validate()? }
		if let Some(ref val) = self.rule {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rule is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 20 {
				return Err(ValidationError::new(1002, "rule exceeds the maximum length of 20".to_string()));
			}
		}
		Ok(())
	}
}


// BillingRate1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BillingRate1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: BillingRateIdentification1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val") )]
	pub val: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DaysInPrd", skip_serializing_if = "Option::is_none") )]
	pub days_in_prd: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DaysInYr", skip_serializing_if = "Option::is_none") )]
	pub days_in_yr: Option<f64>,
}

impl BillingRate1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.id.validate()?;
		Ok(())
	}
}


// BillingRateIdentification1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BillingRateIdentification1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl BillingRateIdentification1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// BillingService2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BillingService2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SvcDtl") )]
	pub svc_dtl: BillingServiceParameters3,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pric", skip_serializing_if = "Option::is_none") )]
	pub pric: Option<BillingPrice1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtMtd") )]
	pub pmt_mtd: ServicePaymentMethod1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlChrgPric") )]
	pub orgnl_chrg_pric: AmountAndDirection34,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlChrgSttlmAmt", skip_serializing_if = "Option::is_none") )]
	pub orgnl_chrg_sttlm_amt: Option<AmountAndDirection34>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BalReqrdAcctAmt", skip_serializing_if = "Option::is_none") )]
	pub bal_reqrd_acct_amt: Option<AmountAndDirection34>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxDsgnt") )]
	pub tax_dsgnt: ServiceTaxDesignation1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxClctn", skip_serializing_if = "Option::is_none") )]
	pub tax_clctn: Option<BillingMethod1Choice>,
}

impl BillingService2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.svc_dtl.validate()?;
		if let Some(ref val) = self.pric { val.validate()? }
		self.pmt_mtd.validate()?;
		self.orgnl_chrg_pric.validate()?;
		if let Some(ref val) = self.orgnl_chrg_sttlm_amt { val.validate()? }
		if let Some(ref val) = self.bal_reqrd_acct_amt { val.validate()? }
		self.tax_dsgnt.validate()?;
		if let Some(ref val) = self.tax_clctn { val.validate()? }
		Ok(())
	}
}


// BillingServiceAdjustment1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BillingServiceAdjustment1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: ServiceAdjustmentType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Desc") )]
	pub desc: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: AmountAndDirection34,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BalReqrdAmt", skip_serializing_if = "Option::is_none") )]
	pub bal_reqrd_amt: Option<AmountAndDirection34>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ErrDt", skip_serializing_if = "Option::is_none") )]
	pub err_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AdjstmntId", skip_serializing_if = "Option::is_none") )]
	pub adjstmnt_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubSvc", skip_serializing_if = "Option::is_none") )]
	pub sub_svc: Option<BillingSubServiceIdentification1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PricChng", skip_serializing_if = "Option::is_none") )]
	pub pric_chng: Option<AmountAndDirection34>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlPric", skip_serializing_if = "Option::is_none") )]
	pub orgnl_pric: Option<AmountAndDirection34>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NewPric", skip_serializing_if = "Option::is_none") )]
	pub new_pric: Option<AmountAndDirection34>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VolChng", skip_serializing_if = "Option::is_none") )]
	pub vol_chng: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlVol", skip_serializing_if = "Option::is_none") )]
	pub orgnl_vol: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NewVol", skip_serializing_if = "Option::is_none") )]
	pub new_vol: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlChrgAmt", skip_serializing_if = "Option::is_none") )]
	pub orgnl_chrg_amt: Option<AmountAndDirection34>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NewChrgAmt", skip_serializing_if = "Option::is_none") )]
	pub new_chrg_amt: Option<AmountAndDirection34>,
}

impl BillingServiceAdjustment1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tp.validate()?;
		if self.desc.chars().count() < 1 {
			return Err(ValidationError::new(1001, "desc is shorter than the minimum length of 1".to_string()));
		}
		if self.desc.chars().count() > 140 {
			return Err(ValidationError::new(1002, "desc exceeds the maximum length of 140".to_string()));
		}
		self.amt.validate()?;
		if let Some(ref val) = self.bal_reqrd_amt { val.validate()? }
		if let Some(ref val) = self.adjstmnt_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "adjstmnt_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "adjstmnt_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.sub_svc { val.validate()? }
		if let Some(ref val) = self.pric_chng { val.validate()? }
		if let Some(ref val) = self.orgnl_pric { val.validate()? }
		if let Some(ref val) = self.new_pric { val.validate()? }
		if let Some(ref val) = self.orgnl_chrg_amt { val.validate()? }
		if let Some(ref val) = self.new_chrg_amt { val.validate()? }
		Ok(())
	}
}


// BillingServiceCommonIdentification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BillingServiceCommonIdentification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issr") )]
	pub issr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
}

impl BillingServiceCommonIdentification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.issr.chars().count() < 1 {
			return Err(ValidationError::new(1001, "issr is shorter than the minimum length of 1".to_string()));
		}
		if self.issr.chars().count() > 6 {
			return Err(ValidationError::new(1002, "issr exceeds the maximum length of 6".to_string()));
		}
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 8 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 8".to_string()));
		}
		Ok(())
	}
}


// BillingServiceIdentification2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BillingServiceIdentification2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubSvc", skip_serializing_if = "Option::is_none") )]
	pub sub_svc: Option<BillingSubServiceIdentification1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Desc") )]
	pub desc: String,
}

impl BillingServiceIdentification2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.sub_svc { val.validate()? }
		if self.desc.chars().count() < 1 {
			return Err(ValidationError::new(1001, "desc is shorter than the minimum length of 1".to_string()));
		}
		if self.desc.chars().count() > 70 {
			return Err(ValidationError::new(1002, "desc exceeds the maximum length of 70".to_string()));
		}
		Ok(())
	}
}


// BillingServiceIdentification3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BillingServiceIdentification3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubSvc", skip_serializing_if = "Option::is_none") )]
	pub sub_svc: Option<BillingSubServiceIdentification1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Desc") )]
	pub desc: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CmonCd", skip_serializing_if = "Option::is_none") )]
	pub cmon_cd: Option<BillingServiceCommonIdentification1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BkTxCd", skip_serializing_if = "Option::is_none") )]
	pub bk_tx_cd: Option<BankTransactionCodeStructure4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SvcTp", skip_serializing_if = "Option::is_none") )]
	pub svc_tp: Option<String>,
}

impl BillingServiceIdentification3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.sub_svc { val.validate()? }
		if self.desc.chars().count() < 1 {
			return Err(ValidationError::new(1001, "desc is shorter than the minimum length of 1".to_string()));
		}
		if self.desc.chars().count() > 70 {
			return Err(ValidationError::new(1002, "desc exceeds the maximum length of 70".to_string()));
		}
		if let Some(ref val) = self.cmon_cd { val.validate()? }
		if let Some(ref val) = self.bk_tx_cd { val.validate()? }
		if let Some(ref val) = self.svc_tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "svc_tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 12 {
				return Err(ValidationError::new(1002, "svc_tp exceeds the maximum length of 12".to_string()));
			}
		}
		Ok(())
	}
}


// BillingServiceParameters2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BillingServiceParameters2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BkSvc") )]
	pub bk_svc: BillingServiceIdentification2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Vol", skip_serializing_if = "Option::is_none") )]
	pub vol: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnitPric", skip_serializing_if = "Option::is_none") )]
	pub unit_pric: Option<AmountAndDirection34>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SvcChrgAmt") )]
	pub svc_chrg_amt: AmountAndDirection34,
}

impl BillingServiceParameters2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.bk_svc.validate()?;
		if let Some(ref val) = self.unit_pric { val.validate()? }
		self.svc_chrg_amt.validate()?;
		Ok(())
	}
}


// BillingServiceParameters3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BillingServiceParameters3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BkSvc") )]
	pub bk_svc: BillingServiceIdentification3,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Vol", skip_serializing_if = "Option::is_none") )]
	pub vol: Option<f64>,
}

impl BillingServiceParameters3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.bk_svc.validate()?;
		Ok(())
	}
}


// BillingServicesAmount1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BillingServicesAmount1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "HstAmt") )]
	pub hst_amt: AmountAndDirection34,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PricgAmt", skip_serializing_if = "Option::is_none") )]
	pub pricg_amt: Option<AmountAndDirection34>,
}

impl BillingServicesAmount1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.hst_amt.validate()?;
		if let Some(ref val) = self.pricg_amt { val.validate()? }
		Ok(())
	}
}


// BillingServicesAmount2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BillingServicesAmount2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "HstAmt") )]
	pub hst_amt: AmountAndDirection34,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmAmt", skip_serializing_if = "Option::is_none") )]
	pub sttlm_amt: Option<AmountAndDirection34>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PricgAmt", skip_serializing_if = "Option::is_none") )]
	pub pricg_amt: Option<AmountAndDirection34>,
}

impl BillingServicesAmount2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.hst_amt.validate()?;
		if let Some(ref val) = self.sttlm_amt { val.validate()? }
		if let Some(ref val) = self.pricg_amt { val.validate()? }
		Ok(())
	}
}


// BillingServicesAmount3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BillingServicesAmount3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SrcAmt") )]
	pub src_amt: AmountAndDirection34,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HstAmt") )]
	pub hst_amt: AmountAndDirection34,
}

impl BillingServicesAmount3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.src_amt.validate()?;
		self.hst_amt.validate()?;
		Ok(())
	}
}


// BillingServicesTax1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BillingServicesTax1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nb") )]
	pub nb: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Desc", skip_serializing_if = "Option::is_none") )]
	pub desc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rate") )]
	pub rate: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HstAmt") )]
	pub hst_amt: AmountAndDirection34,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PricgAmt", skip_serializing_if = "Option::is_none") )]
	pub pricg_amt: Option<AmountAndDirection34>,
}

impl BillingServicesTax1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.nb.chars().count() < 1 {
			return Err(ValidationError::new(1001, "nb is shorter than the minimum length of 1".to_string()));
		}
		if self.nb.chars().count() > 35 {
			return Err(ValidationError::new(1002, "nb exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.desc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "desc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 40 {
				return Err(ValidationError::new(1002, "desc exceeds the maximum length of 40".to_string()));
			}
		}
		self.hst_amt.validate()?;
		if let Some(ref val) = self.pricg_amt { val.validate()? }
		Ok(())
	}
}


// BillingServicesTax2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BillingServicesTax2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nb") )]
	pub nb: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Desc", skip_serializing_if = "Option::is_none") )]
	pub desc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rate") )]
	pub rate: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PricgAmt") )]
	pub pricg_amt: AmountAndDirection34,
}

impl BillingServicesTax2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.nb.chars().count() < 1 {
			return Err(ValidationError::new(1001, "nb is shorter than the minimum length of 1".to_string()));
		}
		if self.nb.chars().count() > 35 {
			return Err(ValidationError::new(1002, "nb exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.desc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "desc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 40 {
				return Err(ValidationError::new(1002, "desc exceeds the maximum length of 40".to_string()));
			}
		}
		self.pricg_amt.validate()?;
		Ok(())
	}
}


// BillingServicesTax3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BillingServicesTax3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nb") )]
	pub nb: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Desc", skip_serializing_if = "Option::is_none") )]
	pub desc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rate") )]
	pub rate: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlTaxAmt") )]
	pub ttl_tax_amt: AmountAndDirection34,
}

impl BillingServicesTax3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.nb.chars().count() < 1 {
			return Err(ValidationError::new(1001, "nb is shorter than the minimum length of 1".to_string()));
		}
		if self.nb.chars().count() > 35 {
			return Err(ValidationError::new(1002, "nb exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.desc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "desc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 40 {
				return Err(ValidationError::new(1002, "desc exceeds the maximum length of 40".to_string()));
			}
		}
		self.ttl_tax_amt.validate()?;
		Ok(())
	}
}


// BillingStatement5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BillingStatement5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "StmtId") )]
	pub stmt_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrToDt") )]
	pub fr_to_dt: DatePeriod1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm") )]
	pub cre_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts") )]
	pub sts: BillingStatementStatus1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctChrtcs") )]
	pub acct_chrtcs: CashAccountCharacteristics5,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RateData", skip_serializing_if = "Option::is_none") )]
	pub rate_data: Option<Vec<BillingRate1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CcyXchg", skip_serializing_if = "Option::is_none") )]
	pub ccy_xchg: Option<Vec<CurrencyExchange6>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Bal", skip_serializing_if = "Option::is_none") )]
	pub bal: Option<Vec<BillingBalance1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Compstn", skip_serializing_if = "Option::is_none") )]
	pub compstn: Option<Vec<BillingCompensation1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Svc", skip_serializing_if = "Option::is_none") )]
	pub svc: Option<Vec<BillingService2>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxRgn", skip_serializing_if = "Option::is_none") )]
	pub tax_rgn: Option<Vec<BillingTaxRegion3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BalAdjstmnt", skip_serializing_if = "Option::is_none") )]
	pub bal_adjstmnt: Option<Vec<BalanceAdjustment1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SvcAdjstmnt", skip_serializing_if = "Option::is_none") )]
	pub svc_adjstmnt: Option<Vec<BillingServiceAdjustment1>>,
}

impl BillingStatement5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.stmt_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "stmt_id is shorter than the minimum length of 1".to_string()));
		}
		if self.stmt_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "stmt_id exceeds the maximum length of 35".to_string()));
		}
		self.fr_to_dt.validate()?;
		self.sts.validate()?;
		self.acct_chrtcs.validate()?;
		if let Some(ref vec) = self.rate_data { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.ccy_xchg { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.bal { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.compstn { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.svc { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.tax_rgn { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.bal_adjstmnt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.svc_adjstmnt { for item in vec { item.validate()? } }
		Ok(())
	}
}


// BillingStatementStatus1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum BillingStatementStatus1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ORGN") )]
	CodeORGN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RPLC") )]
	CodeRPLC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TEST") )]
	CodeTEST,
}

impl BillingStatementStatus1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// BillingSubServiceIdentification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BillingSubServiceIdentification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issr") )]
	pub issr: BillingSubServiceQualifier1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
}

impl BillingSubServiceIdentification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.issr.validate()?;
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		Ok(())
	}
}


// BillingSubServiceQualifier1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BillingSubServiceQualifier1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<BillingSubServiceQualifier1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl BillingSubServiceQualifier1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// BillingSubServiceQualifier1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum BillingSubServiceQualifier1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "LBOX") )]
	CodeLBOX,
	#[cfg_attr( feature = "derive_serde", serde(rename = "STOR") )]
	CodeSTOR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BILA") )]
	CodeBILA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SEQN") )]
	CodeSEQN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MACT") )]
	CodeMACT,
}

impl BillingSubServiceQualifier1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// BillingTaxCalculationMethod1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum BillingTaxCalculationMethod1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "NTAX") )]
	CodeNTAX,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MTDA") )]
	CodeMTDA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MTDB") )]
	CodeMTDB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MTDC") )]
	CodeMTDC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MTDD") )]
	CodeMTDD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UDFD") )]
	CodeUDFD,
}

impl BillingTaxCalculationMethod1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// BillingTaxIdentification3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BillingTaxIdentification3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "VATRegnNb", skip_serializing_if = "Option::is_none") )]
	pub vat_regn_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxRegnNb", skip_serializing_if = "Option::is_none") )]
	pub tax_regn_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxCtct", skip_serializing_if = "Option::is_none") )]
	pub tax_ctct: Option<Contact13>,
}

impl BillingTaxIdentification3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.vat_regn_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "vat_regn_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "vat_regn_nb exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.tax_regn_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tax_regn_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tax_regn_nb exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.tax_ctct { val.validate()? }
		Ok(())
	}
}


// BillingTaxRegion3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BillingTaxRegion3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RgnNb") )]
	pub rgn_nb: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RgnNm") )]
	pub rgn_nm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CstmrTaxId") )]
	pub cstmr_tax_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtDt", skip_serializing_if = "Option::is_none") )]
	pub pt_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SndgFI", skip_serializing_if = "Option::is_none") )]
	pub sndg_fi: Option<BillingTaxIdentification3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvcNb", skip_serializing_if = "Option::is_none") )]
	pub invc_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MtdC", skip_serializing_if = "Option::is_none") )]
	pub mtd_c: Option<BillingMethod4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmAmt") )]
	pub sttlm_amt: AmountAndDirection34,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxDueToRgn") )]
	pub tax_due_to_rgn: AmountAndDirection34,
}

impl BillingTaxRegion3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.rgn_nb.chars().count() < 1 {
			return Err(ValidationError::new(1001, "rgn_nb is shorter than the minimum length of 1".to_string()));
		}
		if self.rgn_nb.chars().count() > 40 {
			return Err(ValidationError::new(1002, "rgn_nb exceeds the maximum length of 40".to_string()));
		}
		if self.rgn_nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "rgn_nm is shorter than the minimum length of 1".to_string()));
		}
		if self.rgn_nm.chars().count() > 40 {
			return Err(ValidationError::new(1002, "rgn_nm exceeds the maximum length of 40".to_string()));
		}
		if self.cstmr_tax_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "cstmr_tax_id is shorter than the minimum length of 1".to_string()));
		}
		if self.cstmr_tax_id.chars().count() > 40 {
			return Err(ValidationError::new(1002, "cstmr_tax_id exceeds the maximum length of 40".to_string()));
		}
		if let Some(ref val) = self.sndg_fi { val.validate()? }
		if let Some(ref val) = self.invc_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "invc_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 40 {
				return Err(ValidationError::new(1002, "invc_nb exceeds the maximum length of 40".to_string()));
			}
		}
		if let Some(ref val) = self.mtd_c { val.validate()? }
		self.sttlm_amt.validate()?;
		self.tax_due_to_rgn.validate()?;
		Ok(())
	}
}


// BinaryFile1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BinaryFile1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MIMETp", skip_serializing_if = "Option::is_none") )]
	pub mime_tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NcodgTp", skip_serializing_if = "Option::is_none") )]
	pub ncodg_tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CharSet", skip_serializing_if = "Option::is_none") )]
	pub char_set: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InclBinryObjct", skip_serializing_if = "Option::is_none") )]
	pub incl_binry_objct: Option<String>,
}

impl BinaryFile1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mime_tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mime_tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "mime_tp exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.ncodg_tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ncodg_tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "ncodg_tp exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.char_set {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "char_set is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "char_set exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.incl_binry_objct {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "incl_binry_objct is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 102400 {
				return Err(ValidationError::new(1002, "incl_binry_objct exceeds the maximum length of 102400".to_string()));
			}
		}
		Ok(())
	}
}


// BlockedHoldingDetails2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BlockedHoldingDetails2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BlckdHldg") )]
	pub blckd_hldg: Holding1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtlHldgUnits", skip_serializing_if = "Option::is_none") )]
	pub prtl_hldg_units: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HldgCertNb", skip_serializing_if = "Option::is_none") )]
	pub hldg_cert_nb: Option<String>,
}

impl BlockedHoldingDetails2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.blckd_hldg.validate()?;
		if let Some(ref val) = self.hldg_cert_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "hldg_cert_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "hldg_cert_nb exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// BlockedReason2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BlockedReason2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<BlockedReason2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl BlockedReason2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// BlockedReason2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum BlockedReason2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "BKRP") )]
	CodeBKRP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CMMT") )]
	CodeCMMT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CNFS") )]
	CodeCNFS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MORT") )]
	CodeMORT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PCOM") )]
	CodePCOM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PLDG") )]
	CodePLDG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TRPE") )]
	CodeTRPE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SANC") )]
	CodeSANC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TRAN") )]
	CodeTRAN,
}

impl BlockedReason2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// BlockedStatusReason2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BlockedStatusReason2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxTp") )]
	pub tx_tp: TransactionType5Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Blckd") )]
	pub blckd: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<Vec<BlockedReason2Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf") )]
	pub addtl_inf: String,
}

impl BlockedStatusReason2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tx_tp.validate()?;
		if let Some(ref vec) = self.rsn { for item in vec { item.validate()? } }
		if self.addtl_inf.chars().count() < 1 {
			return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
		}
		if self.addtl_inf.chars().count() > 350 {
			return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 350".to_string()));
		}
		Ok(())
	}
}


// BlockedStatusReason2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BlockedStatusReason2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NoSpcfdRsn", skip_serializing_if = "Option::is_none") )]
	pub no_spcfd_rsn: Option<NoReasonCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<Vec<BlockedStatusReason2>>,
}

impl BlockedStatusReason2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.no_spcfd_rsn { val.validate()? }
		if let Some(ref vec) = self.rsn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// BondDerivative2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BondDerivative2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issr") )]
	pub issr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MtrtyDt", skip_serializing_if = "Option::is_none") )]
	pub mtrty_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IssncDt", skip_serializing_if = "Option::is_none") )]
	pub issnc_dt: Option<String>,
}

impl BondDerivative2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
		if !pattern.is_match(&self.issr) {
			return Err(ValidationError::new(1005, "issr does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// BondType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum BondType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "EUSB") )]
	CodeEUSB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OEPB") )]
	CodeOEPB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CVTB") )]
	CodeCVTB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CRPB") )]
	CodeCRPB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CVDB") )]
	CodeCVDB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
}

impl BondType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// BookingConfirmation1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BookingConfirmation1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveOrHistoricCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbtInd") )]
	pub cdt_dbt_ind: CreditDebitCode,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XchgRate", skip_serializing_if = "Option::is_none") )]
	pub xchg_rate: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Acct") )]
	pub acct: CashAccount40,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BookgDt", skip_serializing_if = "Option::is_none") )]
	pub bookg_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValDt") )]
	pub val_dt: DateAndDateTime2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Refs") )]
	pub refs: TransactionReferences6,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Chrgs", skip_serializing_if = "Option::is_none") )]
	pub chrgs: Option<Charges6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<String>,
}

impl BookingConfirmation1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.amt.validate()?;
		self.cdt_dbt_ind.validate()?;
		self.acct.validate()?;
		if let Some(ref val) = self.bookg_dt { val.validate()? }
		self.val_dt.validate()?;
		self.refs.validate()?;
		if let Some(ref val) = self.chrgs { val.validate()? }
		if let Some(ref val) = self.rsn {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rsn is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "rsn exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// Branch5Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Branch5Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<OrganisationIdentification15Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctry", skip_serializing_if = "Option::is_none") )]
	pub ctry: Option<String>,
}

impl Branch5Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.id { val.validate()? }
		if let Some(ref val) = self.ctry {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// Branch6Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Branch6Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<PartyIdentification236Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctry", skip_serializing_if = "Option::is_none") )]
	pub ctry: Option<String>,
}

impl Branch6Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.id { val.validate()? }
		if let Some(ref val) = self.ctry {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// BranchAndFinancialInstitutionIdentification6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BranchAndFinancialInstitutionIdentification6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstnId") )]
	pub fin_instn_id: FinancialInstitutionIdentification18,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BrnchId", skip_serializing_if = "Option::is_none") )]
	pub brnch_id: Option<BranchData3>,
}

impl BranchAndFinancialInstitutionIdentification6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.fin_instn_id.validate()?;
		if let Some(ref val) = self.brnch_id { val.validate()? }
		Ok(())
	}
}


// BranchAndFinancialInstitutionIdentification8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BranchAndFinancialInstitutionIdentification8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstnId") )]
	pub fin_instn_id: FinancialInstitutionIdentification23,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BrnchId", skip_serializing_if = "Option::is_none") )]
	pub brnch_id: Option<BranchData5>,
}

impl BranchAndFinancialInstitutionIdentification8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.fin_instn_id.validate()?;
		if let Some(ref val) = self.brnch_id { val.validate()? }
		Ok(())
	}
}


// BranchData3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BranchData3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LEI", skip_serializing_if = "Option::is_none") )]
	pub lei: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstlAdr", skip_serializing_if = "Option::is_none") )]
	pub pstl_adr: Option<PostalAddress24>,
}

impl BranchData3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.lei {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "lei does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.pstl_adr { val.validate()? }
		Ok(())
	}
}


// BranchData4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BranchData4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstlAdr", skip_serializing_if = "Option::is_none") )]
	pub pstl_adr: Option<PostalAddress1>,
}

impl BranchData4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.pstl_adr { val.validate()? }
		Ok(())
	}
}


// BranchData5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BranchData5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LEI", skip_serializing_if = "Option::is_none") )]
	pub lei: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstlAdr", skip_serializing_if = "Option::is_none") )]
	pub pstl_adr: Option<PostalAddress27>,
}

impl BranchData5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.lei {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "lei does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.pstl_adr { val.validate()? }
		Ok(())
	}
}


// BreakdownByCountry2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BreakdownByCountry2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctry") )]
	pub ctry: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshInFcst", skip_serializing_if = "Option::is_none") )]
	pub csh_in_fcst: Option<Vec<CashInForecast5>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshOutFcst", skip_serializing_if = "Option::is_none") )]
	pub csh_out_fcst: Option<Vec<CashOutForecast5>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NetCshFcst", skip_serializing_if = "Option::is_none") )]
	pub net_csh_fcst: Option<Vec<NetCashForecast4>>,
}

impl BreakdownByCountry2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{2,2}").unwrap();
		if !pattern.is_match(&self.ctry) {
			return Err(ValidationError::new(1005, "ctry does not match the required pattern".to_string()));
		}
		if let Some(ref vec) = self.csh_in_fcst { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.csh_out_fcst { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.net_csh_fcst { for item in vec { item.validate()? } }
		Ok(())
	}
}


// BreakdownByCurrency2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BreakdownByCurrency2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ccy") )]
	pub ccy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshOutFcst", skip_serializing_if = "Option::is_none") )]
	pub csh_out_fcst: Option<Vec<CashOutForecast5>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshInFcst", skip_serializing_if = "Option::is_none") )]
	pub csh_in_fcst: Option<Vec<CashInForecast5>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NetCshFcst", skip_serializing_if = "Option::is_none") )]
	pub net_csh_fcst: Option<Vec<NetCashForecast4>>,
}

impl BreakdownByCurrency2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.ccy) {
			return Err(ValidationError::new(1005, "ccy does not match the required pattern".to_string()));
		}
		if let Some(ref vec) = self.csh_out_fcst { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.csh_in_fcst { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.net_csh_fcst { for item in vec { item.validate()? } }
		Ok(())
	}
}


// BreakdownByParty3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BreakdownByParty3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pty") )]
	pub pty: InvestmentAccount42,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlParams", skip_serializing_if = "Option::is_none") )]
	pub addtl_params: Option<AdditionalParameters1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshInFcst", skip_serializing_if = "Option::is_none") )]
	pub csh_in_fcst: Option<Vec<CashInForecast5>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshOutFcst", skip_serializing_if = "Option::is_none") )]
	pub csh_out_fcst: Option<Vec<CashOutForecast5>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NetCshFcst", skip_serializing_if = "Option::is_none") )]
	pub net_csh_fcst: Option<Vec<NetCashForecast4>>,
}

impl BreakdownByParty3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pty.validate()?;
		if let Some(ref val) = self.addtl_params { val.validate()? }
		if let Some(ref vec) = self.csh_in_fcst { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.csh_out_fcst { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.net_csh_fcst { for item in vec { item.validate()? } }
		Ok(())
	}
}


// BreakdownByUserDefinedParameter3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BreakdownByUserDefinedParameter3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pty", skip_serializing_if = "Option::is_none") )]
	pub pty: Option<InvestmentAccount42>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctry", skip_serializing_if = "Option::is_none") )]
	pub ctry: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ccy", skip_serializing_if = "Option::is_none") )]
	pub ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UsrDfnd", skip_serializing_if = "Option::is_none") )]
	pub usr_dfnd: Option<DataFormat2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshInFcst", skip_serializing_if = "Option::is_none") )]
	pub csh_in_fcst: Option<Vec<CashInForecast5>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshOutFcst", skip_serializing_if = "Option::is_none") )]
	pub csh_out_fcst: Option<Vec<CashOutForecast5>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NetCshFcst", skip_serializing_if = "Option::is_none") )]
	pub net_csh_fcst: Option<Vec<NetCashForecast4>>,
}

impl BreakdownByUserDefinedParameter3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.pty { val.validate()? }
		if let Some(ref val) = self.ctry {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.usr_dfnd { val.validate()? }
		if let Some(ref vec) = self.csh_in_fcst { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.csh_out_fcst { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.net_csh_fcst { for item in vec { item.validate()? } }
		Ok(())
	}
}


// BrokeredDeal1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum BrokeredDeal1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "BILA") )]
	CodeBILA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BROK") )]
	CodeBROK,
}

impl BrokeredDeal1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// BusinessApplicationHeader5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BusinessApplicationHeader5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CharSet", skip_serializing_if = "Option::is_none") )]
	pub char_set: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Fr") )]
	pub fr: Party44Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "To") )]
	pub to: Party44Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizMsgIdr") )]
	pub biz_msg_idr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgDefIdr") )]
	pub msg_def_idr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizSvc", skip_serializing_if = "Option::is_none") )]
	pub biz_svc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDt") )]
	pub cre_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CpyDplct", skip_serializing_if = "Option::is_none") )]
	pub cpy_dplct: Option<CopyDuplicate1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PssblDplct", skip_serializing_if = "Option::is_none") )]
	pub pssbl_dplct: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prty", skip_serializing_if = "Option::is_none") )]
	pub prty: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sgntr", skip_serializing_if = "Option::is_none") )]
	pub sgntr: Option<SignatureEnvelope>,
}

impl BusinessApplicationHeader5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.fr.validate()?;
		self.to.validate()?;
		if self.biz_msg_idr.chars().count() < 1 {
			return Err(ValidationError::new(1001, "biz_msg_idr is shorter than the minimum length of 1".to_string()));
		}
		if self.biz_msg_idr.chars().count() > 35 {
			return Err(ValidationError::new(1002, "biz_msg_idr exceeds the maximum length of 35".to_string()));
		}
		if self.msg_def_idr.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_def_idr is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_def_idr.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_def_idr exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.biz_svc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "biz_svc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "biz_svc exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.cpy_dplct { val.validate()? }
		if let Some(ref val) = self.sgntr { val.validate()? }
		Ok(())
	}
}


// BusinessApplicationHeader8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BusinessApplicationHeader8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CharSet", skip_serializing_if = "Option::is_none") )]
	pub char_set: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Fr") )]
	pub fr: Party51Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "To") )]
	pub to: Party51Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizMsgIdr") )]
	pub biz_msg_idr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgDefIdr") )]
	pub msg_def_idr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizSvc", skip_serializing_if = "Option::is_none") )]
	pub biz_svc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktPrctc", skip_serializing_if = "Option::is_none") )]
	pub mkt_prctc: Option<ImplementationSpecification1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDt") )]
	pub cre_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizPrcgDt", skip_serializing_if = "Option::is_none") )]
	pub biz_prcg_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CpyDplct", skip_serializing_if = "Option::is_none") )]
	pub cpy_dplct: Option<CopyDuplicate1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PssblDplct", skip_serializing_if = "Option::is_none") )]
	pub pssbl_dplct: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prty", skip_serializing_if = "Option::is_none") )]
	pub prty: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sgntr", skip_serializing_if = "Option::is_none") )]
	pub sgntr: Option<SignatureEnvelope>,
}

impl BusinessApplicationHeader8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.fr.validate()?;
		self.to.validate()?;
		if self.biz_msg_idr.chars().count() < 1 {
			return Err(ValidationError::new(1001, "biz_msg_idr is shorter than the minimum length of 1".to_string()));
		}
		if self.biz_msg_idr.chars().count() > 35 {
			return Err(ValidationError::new(1002, "biz_msg_idr exceeds the maximum length of 35".to_string()));
		}
		if self.msg_def_idr.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_def_idr is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_def_idr.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_def_idr exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.biz_svc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "biz_svc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "biz_svc exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.mkt_prctc { val.validate()? }
		if let Some(ref val) = self.cpy_dplct { val.validate()? }
		if let Some(ref val) = self.sgntr { val.validate()? }
		Ok(())
	}
}


// BusinessApplicationHeaderV02 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BusinessApplicationHeaderV02 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CharSet", skip_serializing_if = "Option::is_none") )]
	pub char_set: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Fr") )]
	pub fr: Party44Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "To") )]
	pub to: Party44Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizMsgIdr") )]
	pub biz_msg_idr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgDefIdr") )]
	pub msg_def_idr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizSvc", skip_serializing_if = "Option::is_none") )]
	pub biz_svc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktPrctc", skip_serializing_if = "Option::is_none") )]
	pub mkt_prctc: Option<ImplementationSpecification1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDt") )]
	pub cre_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizPrcgDt", skip_serializing_if = "Option::is_none") )]
	pub biz_prcg_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CpyDplct", skip_serializing_if = "Option::is_none") )]
	pub cpy_dplct: Option<CopyDuplicate1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PssblDplct", skip_serializing_if = "Option::is_none") )]
	pub pssbl_dplct: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prty", skip_serializing_if = "Option::is_none") )]
	pub prty: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sgntr", skip_serializing_if = "Option::is_none") )]
	pub sgntr: Option<SignatureEnvelope>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rltd", skip_serializing_if = "Option::is_none") )]
	pub rltd: Option<Vec<BusinessApplicationHeader5>>,
}

impl BusinessApplicationHeaderV02 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.fr.validate()?;
		self.to.validate()?;
		if self.biz_msg_idr.chars().count() < 1 {
			return Err(ValidationError::new(1001, "biz_msg_idr is shorter than the minimum length of 1".to_string()));
		}
		if self.biz_msg_idr.chars().count() > 35 {
			return Err(ValidationError::new(1002, "biz_msg_idr exceeds the maximum length of 35".to_string()));
		}
		if self.msg_def_idr.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_def_idr is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_def_idr.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_def_idr exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.biz_svc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "biz_svc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "biz_svc exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.mkt_prctc { val.validate()? }
		if let Some(ref val) = self.cpy_dplct { val.validate()? }
		if let Some(ref val) = self.sgntr { val.validate()? }
		if let Some(ref vec) = self.rltd { for item in vec { item.validate()? } }
		Ok(())
	}
}


// BusinessApplicationHeaderV04 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BusinessApplicationHeaderV04 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CharSet", skip_serializing_if = "Option::is_none") )]
	pub char_set: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Fr") )]
	pub fr: Party51Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "To") )]
	pub to: Party51Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizMsgIdr") )]
	pub biz_msg_idr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgDefIdr") )]
	pub msg_def_idr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizSvc", skip_serializing_if = "Option::is_none") )]
	pub biz_svc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktPrctc", skip_serializing_if = "Option::is_none") )]
	pub mkt_prctc: Option<ImplementationSpecification1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDt") )]
	pub cre_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizPrcgDt", skip_serializing_if = "Option::is_none") )]
	pub biz_prcg_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CpyDplct", skip_serializing_if = "Option::is_none") )]
	pub cpy_dplct: Option<CopyDuplicate1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PssblDplct", skip_serializing_if = "Option::is_none") )]
	pub pssbl_dplct: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prty", skip_serializing_if = "Option::is_none") )]
	pub prty: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sgntr", skip_serializing_if = "Option::is_none") )]
	pub sgntr: Option<SignatureEnvelope>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rltd", skip_serializing_if = "Option::is_none") )]
	pub rltd: Option<Vec<BusinessApplicationHeader8>>,
}

impl BusinessApplicationHeaderV04 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.fr.validate()?;
		self.to.validate()?;
		if self.biz_msg_idr.chars().count() < 1 {
			return Err(ValidationError::new(1001, "biz_msg_idr is shorter than the minimum length of 1".to_string()));
		}
		if self.biz_msg_idr.chars().count() > 35 {
			return Err(ValidationError::new(1002, "biz_msg_idr exceeds the maximum length of 35".to_string()));
		}
		if self.msg_def_idr.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_def_idr is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_def_idr.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_def_idr exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.biz_svc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "biz_svc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "biz_svc exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.mkt_prctc { val.validate()? }
		if let Some(ref val) = self.cpy_dplct { val.validate()? }
		if let Some(ref val) = self.sgntr { val.validate()? }
		if let Some(ref vec) = self.rltd { for item in vec { item.validate()? } }
		Ok(())
	}
}


// BusinessDay8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BusinessDay8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SysId") )]
	pub sys_id: Vec<SystemIdentification2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizDayOrErr") )]
	pub biz_day_or_err: BusinessDayReportOrError10Choice,
}

impl BusinessDay8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		for item in &self.sys_id { item.validate()? }
		self.biz_day_or_err.validate()?;
		Ok(())
	}
}


// BusinessDay9 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BusinessDay9 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SysDt", skip_serializing_if = "Option::is_none") )]
	pub sys_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SysSts", skip_serializing_if = "Option::is_none") )]
	pub sys_sts: Option<SystemStatus3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SysInfPerCcy", skip_serializing_if = "Option::is_none") )]
	pub sys_inf_per_ccy: Option<Vec<SystemAvailabilityAndEvents3>>,
}

impl BusinessDay9 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.sys_dt { val.validate()? }
		if let Some(ref val) = self.sys_sts { val.validate()? }
		if let Some(ref vec) = self.sys_inf_per_ccy { for item in vec { item.validate()? } }
		Ok(())
	}
}


// BusinessDayConvention1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum BusinessDayConvention1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "FWNG") )]
	CodeFWNG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PREC") )]
	CodePREC,
}

impl BusinessDayConvention1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// BusinessDayCriteria2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BusinessDayCriteria2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NewQryNm", skip_serializing_if = "Option::is_none") )]
	pub new_qry_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SchCrit", skip_serializing_if = "Option::is_none") )]
	pub sch_crit: Option<Vec<BusinessDaySearchCriteria2>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RtrCrit", skip_serializing_if = "Option::is_none") )]
	pub rtr_crit: Option<BusinessDayReturnCriteria2>,
}

impl BusinessDayCriteria2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.new_qry_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "new_qry_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "new_qry_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref vec) = self.sch_crit { for item in vec { item.validate()? } }
		if let Some(ref val) = self.rtr_crit { val.validate()? }
		Ok(())
	}
}


// BusinessDayCriteria3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BusinessDayCriteria3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "QryNm", skip_serializing_if = "Option::is_none") )]
	pub qry_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NewCrit", skip_serializing_if = "Option::is_none") )]
	pub new_crit: Option<BusinessDayCriteria2>,
}

impl BusinessDayCriteria3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.qry_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "qry_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "qry_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.new_crit { val.validate()? }
		Ok(())
	}
}


// BusinessDayQuery2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BusinessDayQuery2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "QryTp", skip_serializing_if = "Option::is_none") )]
	pub qry_tp: Option<QueryType2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Crit", skip_serializing_if = "Option::is_none") )]
	pub crit: Option<BusinessDayCriteria3Choice>,
}

impl BusinessDayQuery2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.qry_tp { val.validate()? }
		if let Some(ref val) = self.crit { val.validate()? }
		Ok(())
	}
}


// BusinessDayReportOrError10Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BusinessDayReportOrError10Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizDayInf", skip_serializing_if = "Option::is_none") )]
	pub biz_day_inf: Option<BusinessDay9>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizErr", skip_serializing_if = "Option::is_none") )]
	pub biz_err: Option<Vec<ErrorHandling5>>,
}

impl BusinessDayReportOrError10Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.biz_day_inf { val.validate()? }
		if let Some(ref vec) = self.biz_err { for item in vec { item.validate()? } }
		Ok(())
	}
}


// BusinessDayReportOrError9Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BusinessDayReportOrError9Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizRpt", skip_serializing_if = "Option::is_none") )]
	pub biz_rpt: Option<Vec<BusinessDay8>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OprlErr", skip_serializing_if = "Option::is_none") )]
	pub oprl_err: Option<Vec<ErrorHandling5>>,
}

impl BusinessDayReportOrError9Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.biz_rpt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.oprl_err { for item in vec { item.validate()? } }
		Ok(())
	}
}


// BusinessDayReturnCriteria2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BusinessDayReturnCriteria2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SysDtInd", skip_serializing_if = "Option::is_none") )]
	pub sys_dt_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SysStsInd", skip_serializing_if = "Option::is_none") )]
	pub sys_sts_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SysCcyInd", skip_serializing_if = "Option::is_none") )]
	pub sys_ccy_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClsrPrdInd", skip_serializing_if = "Option::is_none") )]
	pub clsr_prd_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EvtInd", skip_serializing_if = "Option::is_none") )]
	pub evt_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SsnPrdInd", skip_serializing_if = "Option::is_none") )]
	pub ssn_prd_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EvtTpInd", skip_serializing_if = "Option::is_none") )]
	pub evt_tp_ind: Option<bool>,
}

impl BusinessDayReturnCriteria2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// BusinessDaySearchCriteria2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BusinessDaySearchCriteria2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SysDt", skip_serializing_if = "Option::is_none") )]
	pub sys_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SysId", skip_serializing_if = "Option::is_none") )]
	pub sys_id: Option<Vec<SystemIdentification2Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SysCcy", skip_serializing_if = "Option::is_none") )]
	pub sys_ccy: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EvtTp", skip_serializing_if = "Option::is_none") )]
	pub evt_tp: Option<SystemEventType2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClsrPrd", skip_serializing_if = "Option::is_none") )]
	pub clsr_prd: Option<DateTimePeriod1Choice>,
}

impl BusinessDaySearchCriteria2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.sys_id { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.sys_ccy {
			for item in vec {
				let pattern = Regex::new("[A-Z]{3,3}").unwrap();
				if !pattern.is_match(&item) {
					return Err(ValidationError::new(1005, "sys_ccy does not match the required pattern".to_string()));
				}
			}
		}
		if let Some(ref val) = self.evt_tp { val.validate()? }
		if let Some(ref val) = self.clsr_prd { val.validate()? }
		Ok(())
	}
}


// BusinessError4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BusinessError4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmId") )]
	pub fin_instrm_id: SecurityIdentification39,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizErr") )]
	pub biz_err: Vec<ErrorHandling5>,
}

impl BusinessError4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.fin_instrm_id.validate()?;
		for item in &self.biz_err { item.validate()? }
		Ok(())
	}
}


// BusinessFileHeaderV01 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BusinessFileHeaderV01 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PyldDesc") )]
	pub pyld_desc: PayloadDescription2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pyld", skip_serializing_if = "Option::is_none") )]
	pub pyld: Option<Vec<LaxPayload>>,
}

impl BusinessFileHeaderV01 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pyld_desc.validate()?;
		if let Some(ref vec) = self.pyld { for item in vec { item.validate()? } }
		Ok(())
	}
}


// BusinessInformationCriteria1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BusinessInformationCriteria1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NewQryNm", skip_serializing_if = "Option::is_none") )]
	pub new_qry_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SchCrit", skip_serializing_if = "Option::is_none") )]
	pub sch_crit: Option<Vec<GeneralBusinessInformationSearchCriteria1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RtrCrit", skip_serializing_if = "Option::is_none") )]
	pub rtr_crit: Option<GeneralBusinessInformationReturnCriteria1>,
}

impl BusinessInformationCriteria1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.new_qry_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "new_qry_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "new_qry_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref vec) = self.sch_crit { for item in vec { item.validate()? } }
		if let Some(ref val) = self.rtr_crit { val.validate()? }
		Ok(())
	}
}


// BusinessInformationQueryDefinition3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct BusinessInformationQueryDefinition3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "QryTp", skip_serializing_if = "Option::is_none") )]
	pub qry_tp: Option<QueryType2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GnlBizInfCrit", skip_serializing_if = "Option::is_none") )]
	pub gnl_biz_inf_crit: Option<GeneralBusinessInformationCriteriaDefinition1Choice>,
}

impl BusinessInformationQueryDefinition3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.qry_tp { val.validate()? }
		if let Some(ref val) = self.gnl_biz_inf_crit { val.validate()? }
		Ok(())
	}
}


// CRSForm1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CRSForm1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<CRSFormType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl CRSForm1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// CRSFormType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CRSFormType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CER4") )]
	CodeCER4,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CER3") )]
	CodeCER3,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CER5") )]
	CodeCER5,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CER6") )]
	CodeCER6,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CER8") )]
	CodeCER8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CER1") )]
	CodeCER1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CER2") )]
	CodeCER2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CER7") )]
	CodeCER7,
}

impl CRSFormType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CRSSource1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CRSSource1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<CRSSourceStatus1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl CRSSource1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// CRSSourceStatus1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CRSSourceStatus1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CALC") )]
	CodeCALC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DECL") )]
	CodeDECL,
}

impl CRSSourceStatus1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CRSStatus1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CRSStatus1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "C101") )]
	CodeC101,
	#[cfg_attr( feature = "derive_serde", serde(rename = "C102") )]
	CodeC102,
	#[cfg_attr( feature = "derive_serde", serde(rename = "C103") )]
	CodeC103,
	#[cfg_attr( feature = "derive_serde", serde(rename = "C104") )]
	CodeC104,
	#[cfg_attr( feature = "derive_serde", serde(rename = "C105") )]
	CodeC105,
	#[cfg_attr( feature = "derive_serde", serde(rename = "C106") )]
	CodeC106,
	#[cfg_attr( feature = "derive_serde", serde(rename = "C107") )]
	CodeC107,
	#[cfg_attr( feature = "derive_serde", serde(rename = "C108") )]
	CodeC108,
	#[cfg_attr( feature = "derive_serde", serde(rename = "C109") )]
	CodeC109,
	#[cfg_attr( feature = "derive_serde", serde(rename = "C110") )]
	CodeC110,
	#[cfg_attr( feature = "derive_serde", serde(rename = "C111") )]
	CodeC111,
	#[cfg_attr( feature = "derive_serde", serde(rename = "C112") )]
	CodeC112,
	#[cfg_attr( feature = "derive_serde", serde(rename = "C113") )]
	CodeC113,
	#[cfg_attr( feature = "derive_serde", serde(rename = "C114") )]
	CodeC114,
}

impl CRSStatus1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CRSStatus3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CRSStatus3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<CRSStatus1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl CRSStatus3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// CRSStatus4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CRSStatus4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: CRSStatus3Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Src", skip_serializing_if = "Option::is_none") )]
	pub src: Option<CRSSource1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XcptnlRptgCtry", skip_serializing_if = "Option::is_none") )]
	pub xcptnl_rptg_ctry: Option<String>,
}

impl CRSStatus4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tp.validate()?;
		if let Some(ref val) = self.src { val.validate()? }
		if let Some(ref val) = self.xcptnl_rptg_ctry {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "xcptnl_rptg_ctry does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// CSCManagement1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CSCManagement1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRST") )]
	CodePRST,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BYPS") )]
	CodeBYPS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UNRD") )]
	CodeUNRD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NCSC") )]
	CodeNCSC,
}

impl CSCManagement1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CalculationBasis2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CalculationBasis2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "AVER") )]
	CodeAVER,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DAIL") )]
	CodeDAIL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MNTH") )]
	CodeMNTH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "YEAR") )]
	CodeYEAR,
}

impl CalculationBasis2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CalculationType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CalculationType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "AFTX") )]
	CodeAFTX,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ANNU") )]
	CodeANNU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISSU") )]
	CodeISSU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AVMA") )]
	CodeAVMA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BOOK") )]
	CodeBOOK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "YTNC") )]
	CodeYTNC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CHCL") )]
	CodeCHCL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CLOS") )]
	CodeCLOS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CMPD") )]
	CodeCMPD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CUYI") )]
	CodeCUYI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TRGR") )]
	CodeTRGR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GVEQ") )]
	CodeGVEQ,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FLAS") )]
	CodeFLAS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NVFL") )]
	CodeNVFL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LSCL") )]
	CodeLSCL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LSMT") )]
	CodeLSMT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LSQR") )]
	CodeLSQR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LSYR") )]
	CodeLSYR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LGAL") )]
	CodeLGAL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MARK") )]
	CodeMARK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "YTMA") )]
	CodeYTMA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NXRF") )]
	CodeNXRF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PNAV") )]
	CodePNAV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NXPT") )]
	CodeNXPT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRCL") )]
	CodePRCL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRYL") )]
	CodePRYL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SEMI") )]
	CodeSEMI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SHLF") )]
	CodeSHLF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SPLL") )]
	CodeSPLL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TXQV") )]
	CodeTXQV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TTDT") )]
	CodeTTDT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TRYL") )]
	CodeTRYL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WRST") )]
	CodeWRST,
}

impl CalculationType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CalculationType3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CalculationType3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<CalculationType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl CalculationType3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// CalendarData1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CalendarData1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SysDt") )]
	pub sys_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SysSts") )]
	pub sys_sts: SystemStatus3Choice,
}

impl CalendarData1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.sys_sts.validate()?;
		Ok(())
	}
}


// CalendarOrBusinessError1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CalendarOrBusinessError1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CalData", skip_serializing_if = "Option::is_none") )]
	pub cal_data: Option<Vec<CalendarData1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizErr", skip_serializing_if = "Option::is_none") )]
	pub biz_err: Option<Vec<ErrorHandling4>>,
}

impl CalendarOrBusinessError1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.cal_data { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.biz_err { for item in vec { item.validate()? } }
		Ok(())
	}
}


// CalendarReport1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CalendarReport1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Svc", skip_serializing_if = "Option::is_none") )]
	pub svc: Option<SystemAndCurrency1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CalOrErr") )]
	pub cal_or_err: CalendarOrBusinessError1Choice,
}

impl CalendarReport1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.svc { val.validate()? }
		self.cal_or_err.validate()?;
		Ok(())
	}
}


// CalendarReportOrError1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CalendarReportOrError1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CalRpt", skip_serializing_if = "Option::is_none") )]
	pub cal_rpt: Option<CalendarReport1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OprlErr", skip_serializing_if = "Option::is_none") )]
	pub oprl_err: Option<Vec<ErrorHandling4>>,
}

impl CalendarReportOrError1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cal_rpt { val.validate()? }
		if let Some(ref vec) = self.oprl_err { for item in vec { item.validate()? } }
		Ok(())
	}
}


// CalendarSearchCriteria1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CalendarSearchCriteria1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Yr", skip_serializing_if = "Option::is_none") )]
	pub yr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mnth", skip_serializing_if = "Option::is_none") )]
	pub mnth: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Svc", skip_serializing_if = "Option::is_none") )]
	pub svc: Option<SystemAndCurrency1>,
}

impl CalendarSearchCriteria1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.svc { val.validate()? }
		Ok(())
	}
}


// CallIn1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CallIn1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CFAV") )]
	CodeCFAV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CFST") )]
	CodeCFST,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CFCC") )]
	CodeCFCC,
}

impl CallIn1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CallType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CallType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "LOTT") )]
	CodeLOTT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRTA") )]
	CodePRTA,
}

impl CallType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CallType3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CallType3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<CallType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl CallType3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// CancelOrderReport1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CancelOrderReport1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptId") )]
	pub rpt_id: String,
}

impl CancelOrderReport1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.rpt_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "rpt_id is shorter than the minimum length of 1".to_string()));
		}
		if self.rpt_id.chars().count() > 140 {
			return Err(ValidationError::new(1002, "rpt_id exceeds the maximum length of 140".to_string()));
		}
		Ok(())
	}
}


// CancellationIndividualStatus1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CancellationIndividualStatus1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "RJCR") )]
	CodeRJCR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACCR") )]
	CodeACCR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PDCR") )]
	CodePDCR,
}

impl CancellationIndividualStatus1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CancellationProcessingStatus3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CancellationProcessingStatus3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CANP") )]
	CodeCANP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REJT") )]
	CodeREJT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REPR") )]
	CodeREPR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PACK") )]
	CodePACK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DEND") )]
	CodeDEND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CAND") )]
	CodeCAND,
}

impl CancellationProcessingStatus3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CancellationProcessingStatus9Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CancellationProcessingStatus9Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<CancellationProcessingStatus3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl CancellationProcessingStatus9Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// CancellationReason10 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CancellationReason10 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd") )]
	pub cd: CancellationReason21Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlRsnInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_rsn_inf: Option<String>,
}

impl CancellationReason10 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.cd.validate()?;
		if let Some(ref val) = self.addtl_rsn_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_rsn_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 210 {
				return Err(ValidationError::new(1002, "addtl_rsn_inf exceeds the maximum length of 210".to_string()));
			}
		}
		Ok(())
	}
}


// CancellationReason19Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CancellationReason19Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<CancelledStatusReason13Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl CancellationReason19Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// CancellationReason21Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CancellationReason21Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<CancelledStatusReason5Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl CancellationReason21Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// CancellationReason33Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CancellationReason33Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl CancellationReason33Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// CancellationReason9 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CancellationReason9 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd") )]
	pub cd: CancellationReason19Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlRsnInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_rsn_inf: Option<String>,
}

impl CancellationReason9 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.cd.validate()?;
		if let Some(ref val) = self.addtl_rsn_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_rsn_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 210 {
				return Err(ValidationError::new(1002, "addtl_rsn_inf exceeds the maximum length of 210".to_string()));
			}
		}
		Ok(())
	}
}


// CancellationStatus14Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CancellationStatus14Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NoSpcfdRsn", skip_serializing_if = "Option::is_none") )]
	pub no_spcfd_rsn: Option<NoReasonCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<Vec<CancellationReason9>>,
}

impl CancellationStatus14Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.no_spcfd_rsn { val.validate()? }
		if let Some(ref vec) = self.rsn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// CancellationStatus15Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CancellationStatus15Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NoSpcfdRsn", skip_serializing_if = "Option::is_none") )]
	pub no_spcfd_rsn: Option<NoReasonCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<Vec<CancellationReason10>>,
}

impl CancellationStatus15Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.no_spcfd_rsn { val.validate()? }
		if let Some(ref vec) = self.rsn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// CancellationStatusReason3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CancellationStatusReason3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl CancellationStatusReason3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// CancellationStatusReason5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CancellationStatusReason5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Orgtr", skip_serializing_if = "Option::is_none") )]
	pub orgtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<CancellationStatusReason3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<Vec<String>>,
}

impl CancellationStatusReason5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgtr { val.validate()? }
		if let Some(ref val) = self.rsn { val.validate()? }
		if let Some(ref vec) = self.addtl_inf {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 105 {
					return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 105".to_string()));
				}
			}
		}
		Ok(())
	}
}


// CancelledStatusReason13Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CancelledStatusReason13Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CANI") )]
	CodeCANI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CANS") )]
	CodeCANS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CSUB") )]
	CodeCSUB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CXLR") )]
	CodeCXLR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CANT") )]
	CodeCANT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CANZ") )]
	CodeCANZ,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CORP") )]
	CodeCORP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SCEX") )]
	CodeSCEX,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CTHP") )]
	CodeCTHP,
}

impl CancelledStatusReason13Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CancelledStatusReason15Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CancelledStatusReason15Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CANI") )]
	CodeCANI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CSUB") )]
	CodeCSUB,
}

impl CancelledStatusReason15Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CancelledStatusReason1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CancelledStatusReason1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CANI") )]
	CodeCANI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CANS") )]
	CodeCANS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CSUB") )]
	CodeCSUB,
}

impl CancelledStatusReason1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CancelledStatusReason5Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CancelledStatusReason5Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CANI") )]
	CodeCANI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
}

impl CancelledStatusReason5Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CapitalRequirement1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CapitalRequirement1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "WndgDwnOrRstrgRsk") )]
	pub wndg_dwn_or_rstrg_rsk: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OprlAndLglRsk") )]
	pub oprl_and_lgl_rsk: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtRsk") )]
	pub cdt_rsk: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CntrPtyRsk") )]
	pub cntr_pty_rsk: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktRsk") )]
	pub mkt_rsk: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizRsk") )]
	pub biz_rsk: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtfctnBffr", skip_serializing_if = "Option::is_none") )]
	pub ntfctn_bffr: Option<f64>,
}

impl CapitalRequirement1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.wndg_dwn_or_rstrg_rsk.validate()?;
		self.oprl_and_lgl_rsk.validate()?;
		self.cdt_rsk.validate()?;
		self.cntr_pty_rsk.validate()?;
		self.mkt_rsk.validate()?;
		self.biz_rsk.validate()?;
		Ok(())
	}
}


// CardAggregated2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CardAggregated2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlSvc", skip_serializing_if = "Option::is_none") )]
	pub addtl_svc: Option<CardPaymentServiceType2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxCtgy", skip_serializing_if = "Option::is_none") )]
	pub tx_ctgy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SaleRcncltnId", skip_serializing_if = "Option::is_none") )]
	pub sale_rcncltn_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SeqNbRg", skip_serializing_if = "Option::is_none") )]
	pub seq_nb_rg: Option<CardSequenceNumberRange1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxDtRg", skip_serializing_if = "Option::is_none") )]
	pub tx_dt_rg: Option<DateOrDateTimePeriod1Choice>,
}

impl CardAggregated2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.addtl_svc { val.validate()? }
		if let Some(ref val) = self.tx_ctgy {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tx_ctgy is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "tx_ctgy exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.sale_rcncltn_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "sale_rcncltn_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "sale_rcncltn_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.seq_nb_rg { val.validate()? }
		if let Some(ref val) = self.tx_dt_rg { val.validate()? }
		Ok(())
	}
}


// CardDataReading1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CardDataReading1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "TAGC") )]
	CodeTAGC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PHYS") )]
	CodePHYS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BRCD") )]
	CodeBRCD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MGST") )]
	CodeMGST,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CICC") )]
	CodeCICC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DFLE") )]
	CodeDFLE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CTLS") )]
	CodeCTLS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ECTL") )]
	CodeECTL,
}

impl CardDataReading1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CardEntry5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CardEntry5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Card", skip_serializing_if = "Option::is_none") )]
	pub card: Option<PaymentCard4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "POI", skip_serializing_if = "Option::is_none") )]
	pub poi: Option<PointOfInteraction1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AggtdNtry", skip_serializing_if = "Option::is_none") )]
	pub aggtd_ntry: Option<CardAggregated2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrePdAcct", skip_serializing_if = "Option::is_none") )]
	pub pre_pd_acct: Option<CashAccount40>,
}

impl CardEntry5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.card { val.validate()? }
		if let Some(ref val) = self.poi { val.validate()? }
		if let Some(ref val) = self.aggtd_ntry { val.validate()? }
		if let Some(ref val) = self.pre_pd_acct { val.validate()? }
		Ok(())
	}
}


// CardIndividualTransaction2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CardIndividualTransaction2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ICCRltdData", skip_serializing_if = "Option::is_none") )]
	pub icc_rltd_data: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtCntxt", skip_serializing_if = "Option::is_none") )]
	pub pmt_cntxt: Option<PaymentContext3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlSvc", skip_serializing_if = "Option::is_none") )]
	pub addtl_svc: Option<CardPaymentServiceType2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxCtgy", skip_serializing_if = "Option::is_none") )]
	pub tx_ctgy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SaleRcncltnId", skip_serializing_if = "Option::is_none") )]
	pub sale_rcncltn_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SaleRefNb", skip_serializing_if = "Option::is_none") )]
	pub sale_ref_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RePresntmntRsn", skip_serializing_if = "Option::is_none") )]
	pub re_presntmnt_rsn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SeqNb", skip_serializing_if = "Option::is_none") )]
	pub seq_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxId", skip_serializing_if = "Option::is_none") )]
	pub tx_id: Option<TransactionIdentifier1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pdct", skip_serializing_if = "Option::is_none") )]
	pub pdct: Option<Product2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldtnDt", skip_serializing_if = "Option::is_none") )]
	pub vldtn_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldtnSeqNb", skip_serializing_if = "Option::is_none") )]
	pub vldtn_seq_nb: Option<String>,
}

impl CardIndividualTransaction2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.icc_rltd_data {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "icc_rltd_data is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 1025 {
				return Err(ValidationError::new(1002, "icc_rltd_data exceeds the maximum length of 1025".to_string()));
			}
		}
		if let Some(ref val) = self.pmt_cntxt { val.validate()? }
		if let Some(ref val) = self.addtl_svc { val.validate()? }
		if let Some(ref val) = self.tx_ctgy {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tx_ctgy is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "tx_ctgy exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.sale_rcncltn_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "sale_rcncltn_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "sale_rcncltn_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.sale_ref_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "sale_ref_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "sale_ref_nb exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.re_presntmnt_rsn {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "re_presntmnt_rsn is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "re_presntmnt_rsn exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.seq_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "seq_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "seq_nb exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.tx_id { val.validate()? }
		if let Some(ref val) = self.pdct { val.validate()? }
		if let Some(ref val) = self.vldtn_seq_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "vldtn_seq_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "vldtn_seq_nb exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// CardPaymentServiceType2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CardPaymentServiceType2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "AGGR") )]
	CodeAGGR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DCCV") )]
	CodeDCCV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GRTT") )]
	CodeGRTT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INSP") )]
	CodeINSP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LOYT") )]
	CodeLOYT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NRES") )]
	CodeNRES,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PUCO") )]
	CodePUCO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RECP") )]
	CodeRECP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SOAF") )]
	CodeSOAF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UNAF") )]
	CodeUNAF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VCAU") )]
	CodeVCAU,
}

impl CardPaymentServiceType2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CardSecurityInformation1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CardSecurityInformation1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CSCMgmt") )]
	pub csc_mgmt: CSCManagement1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CSCVal", skip_serializing_if = "Option::is_none") )]
	pub csc_val: Option<String>,
}

impl CardSecurityInformation1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.csc_mgmt.validate()?;
		if let Some(ref val) = self.csc_val {
			let pattern = Regex::new("[0-9]{3,4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "csc_val does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// CardSequenceNumberRange1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CardSequenceNumberRange1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrstTx", skip_serializing_if = "Option::is_none") )]
	pub frst_tx: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LastTx", skip_serializing_if = "Option::is_none") )]
	pub last_tx: Option<String>,
}

impl CardSequenceNumberRange1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.frst_tx {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "frst_tx is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "frst_tx exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.last_tx {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "last_tx is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "last_tx exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// CardTransaction18 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CardTransaction18 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Card", skip_serializing_if = "Option::is_none") )]
	pub card: Option<PaymentCard4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "POI", skip_serializing_if = "Option::is_none") )]
	pub poi: Option<PointOfInteraction1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tx", skip_serializing_if = "Option::is_none") )]
	pub tx: Option<CardTransaction3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrePdAcct", skip_serializing_if = "Option::is_none") )]
	pub pre_pd_acct: Option<CashAccount40>,
}

impl CardTransaction18 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.card { val.validate()? }
		if let Some(ref val) = self.poi { val.validate()? }
		if let Some(ref val) = self.tx { val.validate()? }
		if let Some(ref val) = self.pre_pd_acct { val.validate()? }
		Ok(())
	}
}


// CardTransaction3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CardTransaction3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Aggtd", skip_serializing_if = "Option::is_none") )]
	pub aggtd: Option<CardAggregated2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Indv", skip_serializing_if = "Option::is_none") )]
	pub indv: Option<CardIndividualTransaction2>,
}

impl CardTransaction3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.aggtd { val.validate()? }
		if let Some(ref val) = self.indv { val.validate()? }
		Ok(())
	}
}


// CardType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CardType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CRDT") )]
	CodeCRDT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DBIT") )]
	CodeDBIT,
}

impl CardType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CardholderAuthentication2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CardholderAuthentication2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AuthntcnMtd") )]
	pub authntcn_mtd: AuthenticationMethod1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AuthntcnNtty") )]
	pub authntcn_ntty: AuthenticationEntity1Code,
}

impl CardholderAuthentication2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.authntcn_mtd.validate()?;
		self.authntcn_ntty.validate()?;
		Ok(())
	}
}


// CardholderVerificationCapability1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CardholderVerificationCapability1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "MNSG") )]
	CodeMNSG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NPIN") )]
	CodeNPIN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FCPN") )]
	CodeFCPN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FEPN") )]
	CodeFEPN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FDSG") )]
	CodeFDSG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FBIO") )]
	CodeFBIO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MNVR") )]
	CodeMNVR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FBIG") )]
	CodeFBIG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "APKI") )]
	CodeAPKI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PKIS") )]
	CodePKIS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CHDT") )]
	CodeCHDT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SCEC") )]
	CodeSCEC,
}

impl CardholderVerificationCapability1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Case6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Case6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cretr") )]
	pub cretr: Party50Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReopCaseIndctn", skip_serializing_if = "Option::is_none") )]
	pub reop_case_indctn: Option<bool>,
}

impl Case6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		self.cretr.validate()?;
		Ok(())
	}
}


// CaseAssignment6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CaseAssignment6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Assgnr") )]
	pub assgnr: Party50Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Assgne") )]
	pub assgne: Party50Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm") )]
	pub cre_dt_tm: String,
}

impl CaseAssignment6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		self.assgnr.validate()?;
		self.assgne.validate()?;
		Ok(())
	}
}


// CaseForwardingNotification3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CaseForwardingNotification3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Justfn") )]
	pub justfn: CaseForwardingNotification3Code,
}

impl CaseForwardingNotification3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.justfn.validate()?;
		Ok(())
	}
}


// CaseForwardingNotification3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CaseForwardingNotification3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "FTHI") )]
	CodeFTHI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CANC") )]
	CodeCANC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MODI") )]
	CodeMODI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DTAU") )]
	CodeDTAU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SAIN") )]
	CodeSAIN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MINE") )]
	CodeMINE,
}

impl CaseForwardingNotification3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CaseStatus2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CaseStatus2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtTm") )]
	pub dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CaseSts") )]
	pub case_sts: CaseStatus2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<String>,
}

impl CaseStatus2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.case_sts.validate()?;
		if let Some(ref val) = self.rsn {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rsn is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "rsn exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// CaseStatus2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CaseStatus2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CLSD") )]
	CodeCLSD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ASGN") )]
	CodeASGN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INVE") )]
	CodeINVE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UKNW") )]
	CodeUKNW,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ODUE") )]
	CodeODUE,
}

impl CaseStatus2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CashAccount204 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CashAccount204 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmCcy") )]
	pub sttlm_ccy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: AccountIdentificationAndName5,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctOwnr", skip_serializing_if = "Option::is_none") )]
	pub acct_ownr: Option<PartyIdentification125Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcr", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr: Option<FinancialInstitutionIdentification11Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcrBrnch", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr_brnch: Option<BranchData4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctOwnrOthrId", skip_serializing_if = "Option::is_none") )]
	pub acct_ownr_othr_id: Option<Vec<GenericIdentification82>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstmtAcctTp", skip_serializing_if = "Option::is_none") )]
	pub invstmt_acct_tp: Option<AccountType2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbt", skip_serializing_if = "Option::is_none") )]
	pub cdt_dbt: Option<CreditDebit3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmInstrRsn", skip_serializing_if = "Option::is_none") )]
	pub sttlm_instr_rsn: Option<SettlementInstructionReason1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshAcctPurp", skip_serializing_if = "Option::is_none") )]
	pub csh_acct_purp: Option<CashAccountType3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshAcctDsgnt", skip_serializing_if = "Option::is_none") )]
	pub csh_acct_dsgnt: Option<AccountDesignation1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DvddPctg", skip_serializing_if = "Option::is_none") )]
	pub dvdd_pctg: Option<f64>,
}

impl CashAccount204 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.sttlm_ccy) {
			return Err(ValidationError::new(1005, "sttlm_ccy does not match the required pattern".to_string()));
		}
		self.id.validate()?;
		if let Some(ref val) = self.acct_ownr { val.validate()? }
		if let Some(ref val) = self.acct_svcr { val.validate()? }
		if let Some(ref val) = self.acct_svcr_brnch { val.validate()? }
		if let Some(ref vec) = self.acct_ownr_othr_id { for item in vec { item.validate()? } }
		if let Some(ref val) = self.invstmt_acct_tp { val.validate()? }
		if let Some(ref val) = self.cdt_dbt { val.validate()? }
		if let Some(ref val) = self.sttlm_instr_rsn { val.validate()? }
		if let Some(ref val) = self.csh_acct_purp { val.validate()? }
		if let Some(ref val) = self.csh_acct_dsgnt { val.validate()? }
		if let Some(ref val) = self.dvdd_pctg {
			if *val < 0.000000 {
				return Err(ValidationError::new(1003, "dvdd_pctg is less than the minimum value of 0.000000".to_string()));
			}
			if *val > 100.000000 {
				return Err(ValidationError::new(1004, "dvdd_pctg exceeds the maximum value of 100.000000".to_string()));
			}
		}
		Ok(())
	}
}


// CashAccount205 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CashAccount205 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ccy", skip_serializing_if = "Option::is_none") )]
	pub ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmryAcct", skip_serializing_if = "Option::is_none") )]
	pub pmry_acct: Option<CashAccount206>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ScndryAcct", skip_serializing_if = "Option::is_none") )]
	pub scndry_acct: Option<CashAccount206>,
}

impl CashAccount205 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.pmry_acct { val.validate()? }
		if let Some(ref val) = self.scndry_acct { val.validate()? }
		Ok(())
	}
}


// CashAccount206 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CashAccount206 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctId") )]
	pub acct_id: AccountIdentificationAndName7,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Svcr", skip_serializing_if = "Option::is_none") )]
	pub svcr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctTpDesc", skip_serializing_if = "Option::is_none") )]
	pub acct_tp_desc: Option<String>,
}

impl CashAccount206 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.acct_id.validate()?;
		if let Some(ref val) = self.svcr {
			let pattern = Regex::new("[A-Z0-9]{4,4}[A-Z]{2,2}[A-Z0-9]{2,2}([A-Z0-9]{3,3}){0,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "svcr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.acct_tp_desc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_tp_desc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acct_tp_desc exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// CashAccount40 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CashAccount40 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<AccountIdentification4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<CashAccountType2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ccy", skip_serializing_if = "Option::is_none") )]
	pub ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prxy", skip_serializing_if = "Option::is_none") )]
	pub prxy: Option<ProxyAccountIdentification1>,
}

impl CashAccount40 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.id { val.validate()? }
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 70".to_string()));
			}
		}
		if let Some(ref val) = self.prxy { val.validate()? }
		Ok(())
	}
}


// CashAccount43 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CashAccount43 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<AccountIdentification4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<CashAccountType2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ccy", skip_serializing_if = "Option::is_none") )]
	pub ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prxy", skip_serializing_if = "Option::is_none") )]
	pub prxy: Option<ProxyAccountIdentification1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ownr", skip_serializing_if = "Option::is_none") )]
	pub ownr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Svcr", skip_serializing_if = "Option::is_none") )]
	pub svcr: Option<BranchAndFinancialInstitutionIdentification8>,
}

impl CashAccount43 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.id { val.validate()? }
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 70".to_string()));
			}
		}
		if let Some(ref val) = self.prxy { val.validate()? }
		if let Some(ref val) = self.ownr { val.validate()? }
		if let Some(ref val) = self.svcr { val.validate()? }
		Ok(())
	}
}


// CashAccountAndEntry5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CashAccountAndEntry5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Acct") )]
	pub acct: CashAccount43,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ntry", skip_serializing_if = "Option::is_none") )]
	pub ntry: Option<CashEntry2>,
}

impl CashAccountAndEntry5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.acct.validate()?;
		if let Some(ref val) = self.ntry { val.validate()? }
		Ok(())
	}
}


// CashAccountCharacteristics5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CashAccountCharacteristics5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctLvl") )]
	pub acct_lvl: AccountLevel2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshAcct") )]
	pub csh_acct: CashAccount40,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcr", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrntAcct", skip_serializing_if = "Option::is_none") )]
	pub prnt_acct: Option<ParentCashAccount5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CompstnMtd") )]
	pub compstn_mtd: CompensationMethod1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtAcct", skip_serializing_if = "Option::is_none") )]
	pub dbt_acct: Option<AccountIdentification4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DelydDbtDt", skip_serializing_if = "Option::is_none") )]
	pub delyd_dbt_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmAdvc", skip_serializing_if = "Option::is_none") )]
	pub sttlm_advc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctBalCcyCd") )]
	pub acct_bal_ccy_cd: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmCcyCd", skip_serializing_if = "Option::is_none") )]
	pub sttlm_ccy_cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HstCcyCd", skip_serializing_if = "Option::is_none") )]
	pub hst_ccy_cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tax", skip_serializing_if = "Option::is_none") )]
	pub tax: Option<AccountTax1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcrCtct") )]
	pub acct_svcr_ctct: Contact13,
}

impl CashAccountCharacteristics5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.acct_lvl.validate()?;
		self.csh_acct.validate()?;
		if let Some(ref val) = self.acct_svcr { val.validate()? }
		if let Some(ref val) = self.prnt_acct { val.validate()? }
		self.compstn_mtd.validate()?;
		if let Some(ref val) = self.dbt_acct { val.validate()? }
		if let Some(ref val) = self.sttlm_advc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "sttlm_advc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 105 {
				return Err(ValidationError::new(1002, "sttlm_advc exceeds the maximum length of 105".to_string()));
			}
		}
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.acct_bal_ccy_cd) {
			return Err(ValidationError::new(1005, "acct_bal_ccy_cd does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.sttlm_ccy_cd {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "sttlm_ccy_cd does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.hst_ccy_cd {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "hst_ccy_cd does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.tax { val.validate()? }
		self.acct_svcr_ctct.validate()?;
		Ok(())
	}
}


// CashAccountData1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CashAccountData1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<CashAccountType2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ccy", skip_serializing_if = "Option::is_none") )]
	pub ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prxy", skip_serializing_if = "Option::is_none") )]
	pub prxy: Option<ProxyAccountIdentification1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CurMulLmt", skip_serializing_if = "Option::is_none") )]
	pub cur_mul_lmt: Option<Limit5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ownr", skip_serializing_if = "Option::is_none") )]
	pub ownr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Svcr", skip_serializing_if = "Option::is_none") )]
	pub svcr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MulBal", skip_serializing_if = "Option::is_none") )]
	pub mul_bal: Option<Vec<CashBalance13>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CurBilLmt", skip_serializing_if = "Option::is_none") )]
	pub cur_bil_lmt: Option<Vec<BilateralLimit4>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StgOrdr", skip_serializing_if = "Option::is_none") )]
	pub stg_ordr: Option<Vec<StandingOrder11>>,
}

impl CashAccountData1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 70".to_string()));
			}
		}
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.prxy { val.validate()? }
		if let Some(ref val) = self.cur_mul_lmt { val.validate()? }
		if let Some(ref val) = self.ownr { val.validate()? }
		if let Some(ref val) = self.svcr { val.validate()? }
		if let Some(ref vec) = self.mul_bal { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.cur_bil_lmt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.stg_ordr { for item in vec { item.validate()? } }
		Ok(())
	}
}


// CashAccountEntrySearch8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CashAccountEntrySearch8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctId", skip_serializing_if = "Option::is_none") )]
	pub acct_id: Option<Vec<AccountIdentificationSearchCriteria2Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtryAmt", skip_serializing_if = "Option::is_none") )]
	pub ntry_amt: Option<Vec<ActiveOrHistoricAmountRange2Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtryAmtCcy", skip_serializing_if = "Option::is_none") )]
	pub ntry_amt_ccy: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbtInd", skip_serializing_if = "Option::is_none") )]
	pub cdt_dbt_ind: Option<CreditDebitCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtrySts", skip_serializing_if = "Option::is_none") )]
	pub ntry_sts: Option<Vec<EntryStatus1Code>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtryDt", skip_serializing_if = "Option::is_none") )]
	pub ntry_dt: Option<Vec<DateAndDateTimeSearch3Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctOwnr", skip_serializing_if = "Option::is_none") )]
	pub acct_ownr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcr", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr: Option<BranchAndFinancialInstitutionIdentification8>,
}

impl CashAccountEntrySearch8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.acct_id { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.ntry_amt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.ntry_amt_ccy {
			for item in vec {
				let pattern = Regex::new("[A-Z]{3,3}").unwrap();
				if !pattern.is_match(&item) {
					return Err(ValidationError::new(1005, "ntry_amt_ccy does not match the required pattern".to_string()));
				}
			}
		}
		if let Some(ref val) = self.cdt_dbt_ind { val.validate()? }
		if let Some(ref vec) = self.ntry_sts { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.ntry_dt { for item in vec { item.validate()? } }
		if let Some(ref val) = self.acct_ownr { val.validate()? }
		if let Some(ref val) = self.acct_svcr { val.validate()? }
		Ok(())
	}
}


// CashAccountIdentification8Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CashAccountIdentification8Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<GenericAccountIdentification1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IBAN", skip_serializing_if = "Option::is_none") )]
	pub iban: Option<String>,
}

impl CashAccountIdentification8Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.othr { val.validate()? }
		if let Some(ref val) = self.iban {
			let pattern = Regex::new("[A-Z]{2,2}[0-9]{2,2}[a-zA-Z0-9]{1,30}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "iban does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// CashAccountReturnCriteria5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CashAccountReturnCriteria5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NmInd", skip_serializing_if = "Option::is_none") )]
	pub nm_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CcyInd", skip_serializing_if = "Option::is_none") )]
	pub ccy_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TpInd", skip_serializing_if = "Option::is_none") )]
	pub tp_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MulLmtInd", skip_serializing_if = "Option::is_none") )]
	pub mul_lmt_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MulBalRtrCrit", skip_serializing_if = "Option::is_none") )]
	pub mul_bal_rtr_crit: Option<CashBalanceReturnCriteria2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BilLmtInd", skip_serializing_if = "Option::is_none") )]
	pub bil_lmt_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BilBalRtrCrit", skip_serializing_if = "Option::is_none") )]
	pub bil_bal_rtr_crit: Option<CashBalanceReturnCriteria2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StgOrdrInd", skip_serializing_if = "Option::is_none") )]
	pub stg_ordr_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctOwnrInd", skip_serializing_if = "Option::is_none") )]
	pub acct_ownr_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcrInd", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr_ind: Option<bool>,
}

impl CashAccountReturnCriteria5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mul_bal_rtr_crit { val.validate()? }
		if let Some(ref val) = self.bil_bal_rtr_crit { val.validate()? }
		Ok(())
	}
}


// CashAccountSearchCriteria8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CashAccountSearchCriteria8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctId", skip_serializing_if = "Option::is_none") )]
	pub acct_id: Option<Vec<AccountIdentificationSearchCriteria2Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<Vec<CashAccountType2Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ccy", skip_serializing_if = "Option::is_none") )]
	pub ccy: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Bal", skip_serializing_if = "Option::is_none") )]
	pub bal: Option<Vec<CashBalance14>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctOwnr", skip_serializing_if = "Option::is_none") )]
	pub acct_ownr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcr", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr: Option<BranchAndFinancialInstitutionIdentification8>,
}

impl CashAccountSearchCriteria8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.acct_id { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.tp { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.ccy {
			for item in vec {
				let pattern = Regex::new("[A-Z]{3,3}").unwrap();
				if !pattern.is_match(&item) {
					return Err(ValidationError::new(1005, "ccy does not match the required pattern".to_string()));
				}
			}
		}
		if let Some(ref vec) = self.bal { for item in vec { item.validate()? } }
		if let Some(ref val) = self.acct_ownr { val.validate()? }
		if let Some(ref val) = self.acct_svcr { val.validate()? }
		Ok(())
	}
}


// CashAccountType2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CashAccountType2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl CashAccountType2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// CashAccountType3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CashAccountType3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<CashAccountType5Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl CashAccountType3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// CashAccountType5Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CashAccountType5Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "LEND") )]
	CodeLEND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "COLL") )]
	CodeCOLL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SETT") )]
	CodeSETT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MARR") )]
	CodeMARR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SEGT") )]
	CodeSEGT,
}

impl CashAccountType5Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CashAvailability1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CashAvailability1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dt") )]
	pub dt: CashAvailabilityDate1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveOrHistoricCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbtInd") )]
	pub cdt_dbt_ind: CreditDebitCode,
}

impl CashAvailability1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.dt.validate()?;
		self.amt.validate()?;
		self.cdt_dbt_ind.validate()?;
		Ok(())
	}
}


// CashAvailabilityDate1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CashAvailabilityDate1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfDays", skip_serializing_if = "Option::is_none") )]
	pub nb_of_days: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ActlDt", skip_serializing_if = "Option::is_none") )]
	pub actl_dt: Option<String>,
}

impl CashAvailabilityDate1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nb_of_days {
			let pattern = Regex::new("[\\+]{0,1}[0-9]{1,15}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "nb_of_days does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// CashBalance11 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CashBalance11 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbtInd") )]
	pub cdt_dbt_ind: CreditDebitCode,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<BalanceType9Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts", skip_serializing_if = "Option::is_none") )]
	pub sts: Option<BalanceStatus1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValDt", skip_serializing_if = "Option::is_none") )]
	pub val_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfPmts", skip_serializing_if = "Option::is_none") )]
	pub nb_of_pmts: Option<f64>,
}

impl CashBalance11 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.amt < 0.000000 {
			return Err(ValidationError::new(1003, "amt is less than the minimum value of 0.000000".to_string()));
		}
		self.cdt_dbt_ind.validate()?;
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.sts { val.validate()? }
		if let Some(ref val) = self.val_dt { val.validate()? }
		Ok(())
	}
}


// CashBalance13 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CashBalance13 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbtInd") )]
	pub cdt_dbt_ind: CreditDebitCode,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<BalanceType11Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts", skip_serializing_if = "Option::is_none") )]
	pub sts: Option<BalanceStatus1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValDt", skip_serializing_if = "Option::is_none") )]
	pub val_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrcgDt", skip_serializing_if = "Option::is_none") )]
	pub prcg_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfPmts", skip_serializing_if = "Option::is_none") )]
	pub nb_of_pmts: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RstrctnTp", skip_serializing_if = "Option::is_none") )]
	pub rstrctn_tp: Option<BalanceRestrictionType1>,
}

impl CashBalance13 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.amt < 0.000000 {
			return Err(ValidationError::new(1003, "amt is less than the minimum value of 0.000000".to_string()));
		}
		self.cdt_dbt_ind.validate()?;
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.sts { val.validate()? }
		if let Some(ref val) = self.val_dt { val.validate()? }
		if let Some(ref val) = self.prcg_dt { val.validate()? }
		if let Some(ref val) = self.rstrctn_tp { val.validate()? }
		Ok(())
	}
}


// CashBalance14 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CashBalance14 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<Vec<BalanceType11Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtyTp") )]
	pub ctr_pty_tp: BalanceCounterparty1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtyId", skip_serializing_if = "Option::is_none") )]
	pub ctr_pty_id: Option<Vec<BranchAndFinancialInstitutionIdentification8>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValDt", skip_serializing_if = "Option::is_none") )]
	pub val_dt: Option<Vec<DateAndDateTimeSearch4Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrcgDt", skip_serializing_if = "Option::is_none") )]
	pub prcg_dt: Option<DateAndDateTimeSearch4Choice>,
}

impl CashBalance14 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.tp { for item in vec { item.validate()? } }
		self.ctr_pty_tp.validate()?;
		if let Some(ref vec) = self.ctr_pty_id { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.val_dt { for item in vec { item.validate()? } }
		if let Some(ref val) = self.prcg_dt { val.validate()? }
		Ok(())
	}
}


// CashBalance8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CashBalance8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: BalanceType13,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtLine", skip_serializing_if = "Option::is_none") )]
	pub cdt_line: Option<Vec<CreditLine3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveOrHistoricCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbtInd") )]
	pub cdt_dbt_ind: CreditDebitCode,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dt") )]
	pub dt: DateAndDateTime2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Avlbty", skip_serializing_if = "Option::is_none") )]
	pub avlbty: Option<Vec<CashAvailability1>>,
}

impl CashBalance8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tp.validate()?;
		if let Some(ref vec) = self.cdt_line { for item in vec { item.validate()? } }
		self.amt.validate()?;
		self.cdt_dbt_ind.validate()?;
		self.dt.validate()?;
		if let Some(ref vec) = self.avlbty { for item in vec { item.validate()? } }
		Ok(())
	}
}


// CashBalanceReturnCriteria2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CashBalanceReturnCriteria2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TpInd") )]
	pub tp_ind: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsInd") )]
	pub sts_ind: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValDtInd") )]
	pub val_dt_ind: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrcgDtInd") )]
	pub prcg_dt_ind: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfPmtsInd") )]
	pub nb_of_pmts_ind: bool,
}

impl CashBalanceReturnCriteria2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CashBalanceType3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CashBalanceType3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl CashBalanceType3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// CashCollateral5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CashCollateral5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollId", skip_serializing_if = "Option::is_none") )]
	pub coll_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshAcctId", skip_serializing_if = "Option::is_none") )]
	pub csh_acct_id: Option<AccountIdentification4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AsstNb", skip_serializing_if = "Option::is_none") )]
	pub asst_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DpstAmt", skip_serializing_if = "Option::is_none") )]
	pub dpst_amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DpstTp", skip_serializing_if = "Option::is_none") )]
	pub dpst_tp: Option<DepositType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MtrtyDt", skip_serializing_if = "Option::is_none") )]
	pub mtrty_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValDt", skip_serializing_if = "Option::is_none") )]
	pub val_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XchgRate", skip_serializing_if = "Option::is_none") )]
	pub xchg_rate: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollVal") )]
	pub coll_val: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Hrcut", skip_serializing_if = "Option::is_none") )]
	pub hrcut: Option<f64>,
}

impl CashCollateral5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.coll_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "coll_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "coll_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.csh_acct_id { val.validate()? }
		if let Some(ref val) = self.asst_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "asst_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "asst_nb exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.dpst_amt { val.validate()? }
		if let Some(ref val) = self.dpst_tp { val.validate()? }
		self.coll_val.validate()?;
		Ok(())
	}
}


// CashCompare3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CashCompare3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val", skip_serializing_if = "Option::is_none") )]
	pub val: Option<CompareAmountAndDirection2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HrcutOrMrgn", skip_serializing_if = "Option::is_none") )]
	pub hrcut_or_mrgn: Option<ComparePercentageRate3>,
}

impl CashCompare3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val { val.validate()? }
		if let Some(ref val) = self.hrcut_or_mrgn { val.validate()? }
		Ok(())
	}
}


// CashDeposit1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CashDeposit1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NoteDnmtn") )]
	pub note_dnmtn: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfNotes") )]
	pub nb_of_notes: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveCurrencyAndAmount,
}

impl CashDeposit1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.note_dnmtn.validate()?;
		let pattern = Regex::new("[0-9]{1,15}").unwrap();
		if !pattern.is_match(&self.nb_of_notes) {
			return Err(ValidationError::new(1005, "nb_of_notes does not match the required pattern".to_string()));
		}
		self.amt.validate()?;
		Ok(())
	}
}


// CashEntry2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CashEntry2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dt", skip_serializing_if = "Option::is_none") )]
	pub dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts", skip_serializing_if = "Option::is_none") )]
	pub sts: Option<EntryStatus1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StmtId", skip_serializing_if = "Option::is_none") )]
	pub stmt_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcrRef", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr_ref: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlNtryInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_ntry_inf: Option<Vec<String>>,
}

impl CashEntry2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.amt { val.validate()? }
		if let Some(ref val) = self.dt { val.validate()? }
		if let Some(ref val) = self.sts { val.validate()? }
		if let Some(ref val) = self.id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.stmt_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "stmt_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "stmt_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref vec) = self.addtl_ntry_inf {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "addtl_ntry_inf is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 140 {
					return Err(ValidationError::new(1002, "addtl_ntry_inf exceeds the maximum length of 140".to_string()));
				}
			}
		}
		Ok(())
	}
}


// CashInForecast5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CashInForecast5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshSttlmDt") )]
	pub csh_sttlm_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubTtlAmt", skip_serializing_if = "Option::is_none") )]
	pub sub_ttl_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubTtlUnitsNb", skip_serializing_if = "Option::is_none") )]
	pub sub_ttl_units_nb: Option<FinancialInstrumentQuantity1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XcptnlCshFlowInd", skip_serializing_if = "Option::is_none") )]
	pub xcptnl_csh_flow_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshInBrkdwnDtls", skip_serializing_if = "Option::is_none") )]
	pub csh_in_brkdwn_dtls: Option<Vec<FundCashInBreakdown3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlBal", skip_serializing_if = "Option::is_none") )]
	pub addtl_bal: Option<FundBalance1>,
}

impl CashInForecast5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.sub_ttl_amt { val.validate()? }
		if let Some(ref val) = self.sub_ttl_units_nb { val.validate()? }
		if let Some(ref vec) = self.csh_in_brkdwn_dtls { for item in vec { item.validate()? } }
		if let Some(ref val) = self.addtl_bal { val.validate()? }
		Ok(())
	}
}


// CashInForecast6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CashInForecast6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshSttlmDt") )]
	pub csh_sttlm_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubTtlAmt", skip_serializing_if = "Option::is_none") )]
	pub sub_ttl_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubTtlUnitsNb", skip_serializing_if = "Option::is_none") )]
	pub sub_ttl_units_nb: Option<FinancialInstrumentQuantity1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XcptnlCshFlowInd", skip_serializing_if = "Option::is_none") )]
	pub xcptnl_csh_flow_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlBal", skip_serializing_if = "Option::is_none") )]
	pub addtl_bal: Option<FundBalance1>,
}

impl CashInForecast6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.sub_ttl_amt { val.validate()? }
		if let Some(ref val) = self.sub_ttl_units_nb { val.validate()? }
		if let Some(ref val) = self.addtl_bal { val.validate()? }
		Ok(())
	}
}


// CashInOutForecast7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CashInOutForecast7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshSttlmDt", skip_serializing_if = "Option::is_none") )]
	pub csh_sttlm_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveOrHistoricCurrencyAndAmount,
}

impl CashInOutForecast7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.amt.validate()?;
		Ok(())
	}
}


// CashOutForecast5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CashOutForecast5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshSttlmDt") )]
	pub csh_sttlm_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubTtlAmt", skip_serializing_if = "Option::is_none") )]
	pub sub_ttl_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubTtlUnitsNb", skip_serializing_if = "Option::is_none") )]
	pub sub_ttl_units_nb: Option<FinancialInstrumentQuantity1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XcptnlCshFlowInd", skip_serializing_if = "Option::is_none") )]
	pub xcptnl_csh_flow_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshOutBrkdwnDtls", skip_serializing_if = "Option::is_none") )]
	pub csh_out_brkdwn_dtls: Option<Vec<FundCashOutBreakdown3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlBal", skip_serializing_if = "Option::is_none") )]
	pub addtl_bal: Option<FundBalance1>,
}

impl CashOutForecast5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.sub_ttl_amt { val.validate()? }
		if let Some(ref val) = self.sub_ttl_units_nb { val.validate()? }
		if let Some(ref vec) = self.csh_out_brkdwn_dtls { for item in vec { item.validate()? } }
		if let Some(ref val) = self.addtl_bal { val.validate()? }
		Ok(())
	}
}


// CashOutForecast6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CashOutForecast6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshSttlmDt") )]
	pub csh_sttlm_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubTtlAmt", skip_serializing_if = "Option::is_none") )]
	pub sub_ttl_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubTtlUnitsNb", skip_serializing_if = "Option::is_none") )]
	pub sub_ttl_units_nb: Option<FinancialInstrumentQuantity1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XcptnlCshFlowInd", skip_serializing_if = "Option::is_none") )]
	pub xcptnl_csh_flow_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlBal", skip_serializing_if = "Option::is_none") )]
	pub addtl_bal: Option<FundBalance1>,
}

impl CashOutForecast6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.sub_ttl_amt { val.validate()? }
		if let Some(ref val) = self.sub_ttl_units_nb { val.validate()? }
		if let Some(ref val) = self.addtl_bal { val.validate()? }
		Ok(())
	}
}


// CashParties24 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CashParties24 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cdtr") )]
	pub cdtr: PartyIdentificationAndAccount96,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgt") )]
	pub cdtr_agt: PartyIdentificationAndAccount97,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Intrmy", skip_serializing_if = "Option::is_none") )]
	pub intrmy: Option<PartyIdentificationAndAccount97>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Intrmy2", skip_serializing_if = "Option::is_none") )]
	pub intrmy2: Option<PartyIdentificationAndAccount97>,
}

impl CashParties24 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.cdtr.validate()?;
		self.cdtr_agt.validate()?;
		if let Some(ref val) = self.intrmy { val.validate()? }
		if let Some(ref val) = self.intrmy2 { val.validate()? }
		Ok(())
	}
}


// CashPaymentStatus2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CashPaymentStatus2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "PDNG") )]
	CodePDNG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FINL") )]
	CodeFINL,
}

impl CashPaymentStatus2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CashReuseData1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CashReuseData1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RinvstdCsh") )]
	pub rinvstd_csh: Vec<ReinvestedCashTypeAndAmount1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshRinvstmtRate") )]
	pub csh_rinvstmt_rate: f64,
}

impl CashReuseData1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		for item in &self.rinvstd_csh { item.validate()? }
		Ok(())
	}
}


// CashSettlement3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CashSettlement3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshAcctDtls", skip_serializing_if = "Option::is_none") )]
	pub csh_acct_dtls: Option<Vec<CashAccount204>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrCshSttlmDtls", skip_serializing_if = "Option::is_none") )]
	pub othr_csh_sttlm_dtls: Option<Vec<PaymentInstrument17>>,
}

impl CashSettlement3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.csh_acct_dtls { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.othr_csh_sttlm_dtls { for item in vec { item.validate()? } }
		Ok(())
	}
}


// CashSettlement4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CashSettlement4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModScpIndctn") )]
	pub mod_scp_indctn: DataModification2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshAcctDtls", skip_serializing_if = "Option::is_none") )]
	pub csh_acct_dtls: Option<Vec<CashAccount204>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrCshSttlmDtls", skip_serializing_if = "Option::is_none") )]
	pub othr_csh_sttlm_dtls: Option<Vec<PaymentInstrument17>>,
}

impl CashSettlement4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.mod_scp_indctn.validate()?;
		if let Some(ref vec) = self.csh_acct_dtls { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.othr_csh_sttlm_dtls { for item in vec { item.validate()? } }
		Ok(())
	}
}


// CashSubBalanceTypeAndQuantityBreakdown3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CashSubBalanceTypeAndQuantityBreakdown3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: CashBalanceType3Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QtyBrkdwn", skip_serializing_if = "Option::is_none") )]
	pub qty_brkdwn: Option<Vec<AmountAndQuantityBreakdown1>>,
}

impl CashSubBalanceTypeAndQuantityBreakdown3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tp.validate()?;
		if let Some(ref vec) = self.qty_brkdwn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// CategoryPurpose1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CategoryPurpose1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl CategoryPurpose1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// CertificateIdentification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CertificateIdentification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId", skip_serializing_if = "Option::is_none") )]
	pub msg_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcrRef", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtInfId", skip_serializing_if = "Option::is_none") )]
	pub pmt_inf_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrId", skip_serializing_if = "Option::is_none") )]
	pub instr_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndToEndId", skip_serializing_if = "Option::is_none") )]
	pub end_to_end_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<ProprietaryReference1>,
}

impl CertificateIdentification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.msg_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.acct_svcr_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_svcr_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acct_svcr_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.pmt_inf_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pmt_inf_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "pmt_inf_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.instr_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "instr_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "instr_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.end_to_end_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "end_to_end_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "end_to_end_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// CertificateReference2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CertificateReference2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: CertificateIdentification1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dt", skip_serializing_if = "Option::is_none") )]
	pub dt: Option<String>,
}

impl CertificateReference2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.id.validate()?;
		Ok(())
	}
}


// CertificateType2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CertificateType2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "AMLC") )]
	CodeAMLC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DVLC") )]
	CodeDVLC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DFOR") )]
	CodeDFOR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GOST") )]
	CodeGOST,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IDEN") )]
	CodeIDEN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INCU") )]
	CodeINCU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LREF") )]
	CodeLREF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PASS") )]
	CodePASS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRAD") )]
	CodePRAD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PKIC") )]
	CodePKIC,
}

impl CertificateType2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CertificationType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CertificationType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<CertificateType2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl CertificationType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// Channel2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Channel2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<CommunicationMethod3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl Channel2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// CharacterSearch1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CharacterSearch1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "EQ", skip_serializing_if = "Option::is_none") )]
	pub eq: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NEQ", skip_serializing_if = "Option::is_none") )]
	pub neq: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CT", skip_serializing_if = "Option::is_none") )]
	pub ct: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NCT", skip_serializing_if = "Option::is_none") )]
	pub nct: Option<String>,
}

impl CharacterSearch1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.eq {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "eq is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "eq exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.neq {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "neq is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "neq exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.ct {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ct is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "ct exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.nct {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nct is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "nct exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// Charge15 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Charge15 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<ChargeType9Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XtndedTp", skip_serializing_if = "Option::is_none") )]
	pub xtnded_tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<ActiveCurrencyAnd13DecimalAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rate", skip_serializing_if = "Option::is_none") )]
	pub rate: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClctnBsis", skip_serializing_if = "Option::is_none") )]
	pub clctn_bsis: Option<CalculationBasis2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XtndedClctnBsis", skip_serializing_if = "Option::is_none") )]
	pub xtnded_clctn_bsis: Option<String>,
}

impl Charge15 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.xtnded_tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "xtnded_tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "xtnded_tp exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.amt { val.validate()? }
		if let Some(ref val) = self.clctn_bsis { val.validate()? }
		if let Some(ref val) = self.xtnded_clctn_bsis {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "xtnded_clctn_bsis is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "xtnded_clctn_bsis exceeds the maximum length of 350".to_string()));
			}
		}
		Ok(())
	}
}


// Charge26 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Charge26 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: ChargeType4Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgApld") )]
	pub chrg_apld: AmountOrRate3Choice,
}

impl Charge26 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tp.validate()?;
		self.chrg_apld.validate()?;
		Ok(())
	}
}


// ChargeBearerType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ChargeBearerType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "DEBT") )]
	CodeDEBT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CRED") )]
	CodeCRED,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SHAR") )]
	CodeSHAR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SLEV") )]
	CodeSLEV,
}

impl ChargeBearerType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ChargeType12Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ChargeType12Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "BEND") )]
	CodeBEND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DISC") )]
	CodeDISC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FEND") )]
	CodeFEND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "POST") )]
	CodePOST,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REGF") )]
	CodeREGF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SHIP") )]
	CodeSHIP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SPCN") )]
	CodeSPCN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TRAN") )]
	CodeTRAN,
}

impl ChargeType12Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ChargeType3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ChargeType3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification3>,
}

impl ChargeType3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// ChargeType4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ChargeType4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<ChargeType12Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl ChargeType4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// ChargeType8Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ChargeType8Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<InvestmentFundMiFIDFee2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl ChargeType8Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// ChargeType9Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ChargeType9Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "MANF") )]
	CodeMANF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BEND") )]
	CodeBEND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FEND") )]
	CodeFEND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ADVI") )]
	CodeADVI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CUST") )]
	CodeCUST,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PUBL") )]
	CodePUBL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACCT") )]
	CodeACCT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EQUL") )]
	CodeEQUL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PENA") )]
	CodePENA,
}

impl ChargeType9Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Charges14 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Charges14 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveOrHistoricCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Agt") )]
	pub agt: BranchAndFinancialInstitutionIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AgtAcct", skip_serializing_if = "Option::is_none") )]
	pub agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<ChargeType3Choice>,
}

impl Charges14 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.amt.validate()?;
		self.agt.validate()?;
		if let Some(ref val) = self.agt_acct { val.validate()? }
		if let Some(ref val) = self.tp { val.validate()? }
		Ok(())
	}
}


// Charges15 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Charges15 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlChrgsAndTaxAmt", skip_serializing_if = "Option::is_none") )]
	pub ttl_chrgs_and_tax_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rcrd", skip_serializing_if = "Option::is_none") )]
	pub rcrd: Option<Vec<ChargesRecord8>>,
}

impl Charges15 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ttl_chrgs_and_tax_amt { val.validate()? }
		if let Some(ref vec) = self.rcrd { for item in vec { item.validate()? } }
		Ok(())
	}
}


// Charges16 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Charges16 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveOrHistoricCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Agt") )]
	pub agt: BranchAndFinancialInstitutionIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<ChargeType3Choice>,
}

impl Charges16 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.amt.validate()?;
		self.agt.validate()?;
		if let Some(ref val) = self.tp { val.validate()? }
		Ok(())
	}
}


// Charges3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Charges3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sngl", skip_serializing_if = "Option::is_none") )]
	pub sngl: Option<ChargesRecord9>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PerTx", skip_serializing_if = "Option::is_none") )]
	pub per_tx: Option<ChargesPerTransaction3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PerTp", skip_serializing_if = "Option::is_none") )]
	pub per_tp: Option<Vec<ChargesPerType3>>,
}

impl Charges3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.sngl { val.validate()? }
		if let Some(ref val) = self.per_tx { val.validate()? }
		if let Some(ref vec) = self.per_tp { for item in vec { item.validate()? } }
		Ok(())
	}
}


// Charges4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Charges4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sngl", skip_serializing_if = "Option::is_none") )]
	pub sngl: Option<ChargesRecord10>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PerTx", skip_serializing_if = "Option::is_none") )]
	pub per_tx: Option<ChargesPerTransaction4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PerTp", skip_serializing_if = "Option::is_none") )]
	pub per_tp: Option<Vec<ChargesPerType4>>,
}

impl Charges4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.sngl { val.validate()? }
		if let Some(ref val) = self.per_tx { val.validate()? }
		if let Some(ref vec) = self.per_tp { for item in vec { item.validate()? } }
		Ok(())
	}
}


// Charges6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Charges6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlChrgsAndTaxAmt", skip_serializing_if = "Option::is_none") )]
	pub ttl_chrgs_and_tax_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rcrd", skip_serializing_if = "Option::is_none") )]
	pub rcrd: Option<Vec<ChargesRecord3>>,
}

impl Charges6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ttl_chrgs_and_tax_amt { val.validate()? }
		if let Some(ref vec) = self.rcrd { for item in vec { item.validate()? } }
		Ok(())
	}
}


// Charges7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Charges7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveOrHistoricCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Agt") )]
	pub agt: BranchAndFinancialInstitutionIdentification6,
}

impl Charges7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.amt.validate()?;
		self.agt.validate()?;
		Ok(())
	}
}


// ChargesBreakdown1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ChargesBreakdown1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbtInd", skip_serializing_if = "Option::is_none") )]
	pub cdt_dbt_ind: Option<CreditDebitCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<ChargeType3Choice>,
}

impl ChargesBreakdown1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.amt.validate()?;
		if let Some(ref val) = self.cdt_dbt_ind { val.validate()? }
		if let Some(ref val) = self.tp { val.validate()? }
		Ok(())
	}
}


// ChargesPerTransaction3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ChargesPerTransaction3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsId", skip_serializing_if = "Option::is_none") )]
	pub chrgs_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlChrgsPerTx", skip_serializing_if = "Option::is_none") )]
	pub ttl_chrgs_per_tx: Option<TotalCharges7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsAcctAgt", skip_serializing_if = "Option::is_none") )]
	pub chrgs_acct_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsAcctAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub chrgs_acct_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rcrd") )]
	pub rcrd: Vec<ChargesPerTransactionRecord3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
}

impl ChargesPerTransaction3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.chrgs_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "chrgs_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "chrgs_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.ttl_chrgs_per_tx { val.validate()? }
		if let Some(ref val) = self.chrgs_acct_agt { val.validate()? }
		if let Some(ref val) = self.chrgs_acct_agt_acct { val.validate()? }
		for item in &self.rcrd { item.validate()? }
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// ChargesPerTransaction4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ChargesPerTransaction4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsId", skip_serializing_if = "Option::is_none") )]
	pub chrgs_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlChrgsPerTx", skip_serializing_if = "Option::is_none") )]
	pub ttl_chrgs_per_tx: Option<TotalCharges7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsAcct", skip_serializing_if = "Option::is_none") )]
	pub chrgs_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsAcctOwnr", skip_serializing_if = "Option::is_none") )]
	pub chrgs_acct_ownr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rcrd") )]
	pub rcrd: Vec<ChargesPerTransactionRecord4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
}

impl ChargesPerTransaction4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.chrgs_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "chrgs_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "chrgs_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.ttl_chrgs_per_tx { val.validate()? }
		if let Some(ref val) = self.chrgs_acct { val.validate()? }
		if let Some(ref val) = self.chrgs_acct_ownr { val.validate()? }
		for item in &self.rcrd { item.validate()? }
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// ChargesPerTransactionRecord3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ChargesPerTransactionRecord3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RcrdId", skip_serializing_if = "Option::is_none") )]
	pub rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsRqstr", skip_serializing_if = "Option::is_none") )]
	pub chrgs_rqstr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UndrlygTx") )]
	pub undrlyg_tx: TransactionReferences7,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlChrgsPerRcrd", skip_serializing_if = "Option::is_none") )]
	pub ttl_chrgs_per_rcrd: Option<TotalCharges8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsBrkdwn") )]
	pub chrgs_brkdwn: Vec<ChargesBreakdown1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValDt", skip_serializing_if = "Option::is_none") )]
	pub val_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgt", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsAcctAgt", skip_serializing_if = "Option::is_none") )]
	pub chrgs_acct_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsAcctAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub chrgs_acct_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrForInstdAgt", skip_serializing_if = "Option::is_none") )]
	pub instr_for_instd_agt: Option<InstructionForInstructedAgent1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
}

impl ChargesPerTransactionRecord3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "rcrd_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.chrgs_rqstr { val.validate()? }
		self.undrlyg_tx.validate()?;
		if let Some(ref val) = self.ttl_chrgs_per_rcrd { val.validate()? }
		for item in &self.chrgs_brkdwn { item.validate()? }
		if let Some(ref val) = self.val_dt { val.validate()? }
		if let Some(ref val) = self.dbtr_agt { val.validate()? }
		if let Some(ref val) = self.dbtr_agt_acct { val.validate()? }
		if let Some(ref val) = self.chrgs_acct_agt { val.validate()? }
		if let Some(ref val) = self.chrgs_acct_agt_acct { val.validate()? }
		if let Some(ref val) = self.instr_for_instd_agt { val.validate()? }
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// ChargesPerTransactionRecord4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ChargesPerTransactionRecord4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RcrdId", skip_serializing_if = "Option::is_none") )]
	pub rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsRqstr", skip_serializing_if = "Option::is_none") )]
	pub chrgs_rqstr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UndrlygTx") )]
	pub undrlyg_tx: TransactionReferences7,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlChrgsPerRcrd", skip_serializing_if = "Option::is_none") )]
	pub ttl_chrgs_per_rcrd: Option<TotalCharges8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsBrkdwn") )]
	pub chrgs_brkdwn: Vec<ChargesBreakdown1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValDt", skip_serializing_if = "Option::is_none") )]
	pub val_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgt", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsAcct", skip_serializing_if = "Option::is_none") )]
	pub chrgs_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsAcctOwnr", skip_serializing_if = "Option::is_none") )]
	pub chrgs_acct_ownr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrForInstdAgt", skip_serializing_if = "Option::is_none") )]
	pub instr_for_instd_agt: Option<InstructionForInstructedAgent1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
}

impl ChargesPerTransactionRecord4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "rcrd_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.chrgs_rqstr { val.validate()? }
		self.undrlyg_tx.validate()?;
		if let Some(ref val) = self.ttl_chrgs_per_rcrd { val.validate()? }
		for item in &self.chrgs_brkdwn { item.validate()? }
		if let Some(ref val) = self.val_dt { val.validate()? }
		if let Some(ref val) = self.dbtr_agt { val.validate()? }
		if let Some(ref val) = self.dbtr_agt_acct { val.validate()? }
		if let Some(ref val) = self.chrgs_acct { val.validate()? }
		if let Some(ref val) = self.chrgs_acct_ownr { val.validate()? }
		if let Some(ref val) = self.instr_for_instd_agt { val.validate()? }
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// ChargesPerType3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ChargesPerType3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsId", skip_serializing_if = "Option::is_none") )]
	pub chrgs_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlChrgsPerChrgTp", skip_serializing_if = "Option::is_none") )]
	pub ttl_chrgs_per_chrg_tp: Option<TotalCharges7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsAcctAgt", skip_serializing_if = "Option::is_none") )]
	pub chrgs_acct_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsAcctAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub chrgs_acct_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: ChargeType3Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rcrd") )]
	pub rcrd: Vec<ChargesPerTypeRecord3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
}

impl ChargesPerType3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.chrgs_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "chrgs_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "chrgs_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.ttl_chrgs_per_chrg_tp { val.validate()? }
		if let Some(ref val) = self.chrgs_acct_agt { val.validate()? }
		if let Some(ref val) = self.chrgs_acct_agt_acct { val.validate()? }
		self.tp.validate()?;
		for item in &self.rcrd { item.validate()? }
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// ChargesPerType4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ChargesPerType4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsId", skip_serializing_if = "Option::is_none") )]
	pub chrgs_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlChrgsPerChrgTp", skip_serializing_if = "Option::is_none") )]
	pub ttl_chrgs_per_chrg_tp: Option<TotalCharges7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsAcct", skip_serializing_if = "Option::is_none") )]
	pub chrgs_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsAcctOwnr", skip_serializing_if = "Option::is_none") )]
	pub chrgs_acct_ownr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: ChargeType3Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rcrd") )]
	pub rcrd: Vec<ChargesPerTypeRecord4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
}

impl ChargesPerType4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.chrgs_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "chrgs_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "chrgs_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.ttl_chrgs_per_chrg_tp { val.validate()? }
		if let Some(ref val) = self.chrgs_acct { val.validate()? }
		if let Some(ref val) = self.chrgs_acct_ownr { val.validate()? }
		self.tp.validate()?;
		for item in &self.rcrd { item.validate()? }
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// ChargesPerTypeRecord3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ChargesPerTypeRecord3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RcrdId", skip_serializing_if = "Option::is_none") )]
	pub rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsRqstr", skip_serializing_if = "Option::is_none") )]
	pub chrgs_rqstr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UndrlygTx") )]
	pub undrlyg_tx: TransactionReferences7,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbtInd", skip_serializing_if = "Option::is_none") )]
	pub cdt_dbt_ind: Option<CreditDebitCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValDt", skip_serializing_if = "Option::is_none") )]
	pub val_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgt", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsAcctAgt", skip_serializing_if = "Option::is_none") )]
	pub chrgs_acct_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsAcctAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub chrgs_acct_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrForInstdAgt", skip_serializing_if = "Option::is_none") )]
	pub instr_for_instd_agt: Option<InstructionForInstructedAgent1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
}

impl ChargesPerTypeRecord3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "rcrd_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.chrgs_rqstr { val.validate()? }
		self.undrlyg_tx.validate()?;
		self.amt.validate()?;
		if let Some(ref val) = self.cdt_dbt_ind { val.validate()? }
		if let Some(ref val) = self.val_dt { val.validate()? }
		if let Some(ref val) = self.dbtr_agt { val.validate()? }
		if let Some(ref val) = self.dbtr_agt_acct { val.validate()? }
		if let Some(ref val) = self.chrgs_acct_agt { val.validate()? }
		if let Some(ref val) = self.chrgs_acct_agt_acct { val.validate()? }
		if let Some(ref val) = self.instr_for_instd_agt { val.validate()? }
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// ChargesPerTypeRecord4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ChargesPerTypeRecord4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RcrdId", skip_serializing_if = "Option::is_none") )]
	pub rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsRqstr", skip_serializing_if = "Option::is_none") )]
	pub chrgs_rqstr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UndrlygTx") )]
	pub undrlyg_tx: TransactionReferences7,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbtInd", skip_serializing_if = "Option::is_none") )]
	pub cdt_dbt_ind: Option<CreditDebitCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValDt", skip_serializing_if = "Option::is_none") )]
	pub val_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgt", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsAcct", skip_serializing_if = "Option::is_none") )]
	pub chrgs_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsAcctOwnr", skip_serializing_if = "Option::is_none") )]
	pub chrgs_acct_ownr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrForInstdAgt", skip_serializing_if = "Option::is_none") )]
	pub instr_for_instd_agt: Option<InstructionForInstructedAgent1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
}

impl ChargesPerTypeRecord4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "rcrd_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.chrgs_rqstr { val.validate()? }
		self.undrlyg_tx.validate()?;
		self.amt.validate()?;
		if let Some(ref val) = self.cdt_dbt_ind { val.validate()? }
		if let Some(ref val) = self.val_dt { val.validate()? }
		if let Some(ref val) = self.dbtr_agt { val.validate()? }
		if let Some(ref val) = self.dbtr_agt_acct { val.validate()? }
		if let Some(ref val) = self.chrgs_acct { val.validate()? }
		if let Some(ref val) = self.chrgs_acct_ownr { val.validate()? }
		if let Some(ref val) = self.instr_for_instd_agt { val.validate()? }
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// ChargesRecord10 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ChargesRecord10 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsId", skip_serializing_if = "Option::is_none") )]
	pub chrgs_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RcrdId", skip_serializing_if = "Option::is_none") )]
	pub rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsRqstr", skip_serializing_if = "Option::is_none") )]
	pub chrgs_rqstr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UndrlygTx") )]
	pub undrlyg_tx: TransactionReferences7,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbtInd", skip_serializing_if = "Option::is_none") )]
	pub cdt_dbt_ind: Option<CreditDebitCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValDt", skip_serializing_if = "Option::is_none") )]
	pub val_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgt", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsAcct", skip_serializing_if = "Option::is_none") )]
	pub chrgs_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsAcctOwnr", skip_serializing_if = "Option::is_none") )]
	pub chrgs_acct_ownr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<ChargeType3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrForInstdAgt", skip_serializing_if = "Option::is_none") )]
	pub instr_for_instd_agt: Option<InstructionForInstructedAgent1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
}

impl ChargesRecord10 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.chrgs_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "chrgs_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "chrgs_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "rcrd_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.chrgs_rqstr { val.validate()? }
		self.undrlyg_tx.validate()?;
		self.amt.validate()?;
		if let Some(ref val) = self.cdt_dbt_ind { val.validate()? }
		if let Some(ref val) = self.val_dt { val.validate()? }
		if let Some(ref val) = self.dbtr_agt { val.validate()? }
		if let Some(ref val) = self.dbtr_agt_acct { val.validate()? }
		if let Some(ref val) = self.chrgs_acct { val.validate()? }
		if let Some(ref val) = self.chrgs_acct_ownr { val.validate()? }
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.instr_for_instd_agt { val.validate()? }
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// ChargesRecord3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ChargesRecord3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveOrHistoricCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbtInd", skip_serializing_if = "Option::is_none") )]
	pub cdt_dbt_ind: Option<CreditDebitCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgInclInd", skip_serializing_if = "Option::is_none") )]
	pub chrg_incl_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<ChargeType3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rate", skip_serializing_if = "Option::is_none") )]
	pub rate: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Br", skip_serializing_if = "Option::is_none") )]
	pub br: Option<ChargeBearerType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Agt", skip_serializing_if = "Option::is_none") )]
	pub agt: Option<BranchAndFinancialInstitutionIdentification6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tax", skip_serializing_if = "Option::is_none") )]
	pub tax: Option<TaxCharges2>,
}

impl ChargesRecord3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.amt.validate()?;
		if let Some(ref val) = self.cdt_dbt_ind { val.validate()? }
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.br { val.validate()? }
		if let Some(ref val) = self.agt { val.validate()? }
		if let Some(ref val) = self.tax { val.validate()? }
		Ok(())
	}
}


// ChargesRecord8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ChargesRecord8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveOrHistoricCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbtInd", skip_serializing_if = "Option::is_none") )]
	pub cdt_dbt_ind: Option<CreditDebitCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgInclInd", skip_serializing_if = "Option::is_none") )]
	pub chrg_incl_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<ChargeType3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rate", skip_serializing_if = "Option::is_none") )]
	pub rate: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Br", skip_serializing_if = "Option::is_none") )]
	pub br: Option<ChargeBearerType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Agt", skip_serializing_if = "Option::is_none") )]
	pub agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tax", skip_serializing_if = "Option::is_none") )]
	pub tax: Option<TaxCharges2>,
}

impl ChargesRecord8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.amt.validate()?;
		if let Some(ref val) = self.cdt_dbt_ind { val.validate()? }
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.br { val.validate()? }
		if let Some(ref val) = self.agt { val.validate()? }
		if let Some(ref val) = self.tax { val.validate()? }
		Ok(())
	}
}


// ChargesRecord9 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ChargesRecord9 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsId", skip_serializing_if = "Option::is_none") )]
	pub chrgs_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RcrdId", skip_serializing_if = "Option::is_none") )]
	pub rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsRqstr", skip_serializing_if = "Option::is_none") )]
	pub chrgs_rqstr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UndrlygTx") )]
	pub undrlyg_tx: TransactionReferences7,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbtInd", skip_serializing_if = "Option::is_none") )]
	pub cdt_dbt_ind: Option<CreditDebitCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValDt", skip_serializing_if = "Option::is_none") )]
	pub val_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgt", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsAcctAgt", skip_serializing_if = "Option::is_none") )]
	pub chrgs_acct_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsAcctAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub chrgs_acct_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<ChargeType3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrForInstdAgt", skip_serializing_if = "Option::is_none") )]
	pub instr_for_instd_agt: Option<InstructionForInstructedAgent1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
}

impl ChargesRecord9 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.chrgs_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "chrgs_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "chrgs_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "rcrd_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.chrgs_rqstr { val.validate()? }
		self.undrlyg_tx.validate()?;
		self.amt.validate()?;
		if let Some(ref val) = self.cdt_dbt_ind { val.validate()? }
		if let Some(ref val) = self.val_dt { val.validate()? }
		if let Some(ref val) = self.dbtr_agt { val.validate()? }
		if let Some(ref val) = self.dbtr_agt_acct { val.validate()? }
		if let Some(ref val) = self.chrgs_acct_agt { val.validate()? }
		if let Some(ref val) = self.chrgs_acct_agt_acct { val.validate()? }
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.instr_for_instd_agt { val.validate()? }
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// Cheque17 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Cheque17 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrId", skip_serializing_if = "Option::is_none") )]
	pub instr_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChqNb") )]
	pub chq_nb: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IsseDt") )]
	pub isse_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StlDt", skip_serializing_if = "Option::is_none") )]
	pub stl_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValDt", skip_serializing_if = "Option::is_none") )]
	pub val_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pyer", skip_serializing_if = "Option::is_none") )]
	pub pyer: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PyerAcct", skip_serializing_if = "Option::is_none") )]
	pub pyer_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DrwrAgt", skip_serializing_if = "Option::is_none") )]
	pub drwr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DrwrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub drwr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pyee") )]
	pub pyee: PartyIdentification272,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PyeeAcct", skip_serializing_if = "Option::is_none") )]
	pub pyee_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrForChqAgt", skip_serializing_if = "Option::is_none") )]
	pub instr_for_chq_agt: Option<Vec<InstructionForChequeAgent1>>,
}

impl Cheque17 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.instr_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "instr_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "instr_id exceeds the maximum length of 35".to_string()));
			}
		}
		if self.chq_nb.chars().count() < 1 {
			return Err(ValidationError::new(1001, "chq_nb is shorter than the minimum length of 1".to_string()));
		}
		if self.chq_nb.chars().count() > 35 {
			return Err(ValidationError::new(1002, "chq_nb exceeds the maximum length of 35".to_string()));
		}
		self.amt.validate()?;
		if let Some(ref val) = self.val_dt { val.validate()? }
		if let Some(ref val) = self.pyer { val.validate()? }
		if let Some(ref val) = self.pyer_acct { val.validate()? }
		if let Some(ref val) = self.drwr_agt { val.validate()? }
		if let Some(ref val) = self.drwr_agt_acct { val.validate()? }
		self.pyee.validate()?;
		if let Some(ref val) = self.pyee_acct { val.validate()? }
		if let Some(ref vec) = self.instr_for_chq_agt { for item in vec { item.validate()? } }
		Ok(())
	}
}


// Cheque18 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Cheque18 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrId", skip_serializing_if = "Option::is_none") )]
	pub instr_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlInstrId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_instr_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChqNb") )]
	pub chq_nb: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IsseDt") )]
	pub isse_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StlDt", skip_serializing_if = "Option::is_none") )]
	pub stl_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FctvDt", skip_serializing_if = "Option::is_none") )]
	pub fctv_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DrwrAgt", skip_serializing_if = "Option::is_none") )]
	pub drwr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DrwrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub drwr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pyee", skip_serializing_if = "Option::is_none") )]
	pub pyee: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PyeeAcct", skip_serializing_if = "Option::is_none") )]
	pub pyee_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChqCxlOrStopSts") )]
	pub chq_cxl_or_stop_sts: ChequeCancellationStatus1,
}

impl Cheque18 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.instr_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "instr_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "instr_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_instr_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_instr_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_instr_id exceeds the maximum length of 35".to_string()));
			}
		}
		if self.chq_nb.chars().count() < 1 {
			return Err(ValidationError::new(1001, "chq_nb is shorter than the minimum length of 1".to_string()));
		}
		if self.chq_nb.chars().count() > 35 {
			return Err(ValidationError::new(1002, "chq_nb exceeds the maximum length of 35".to_string()));
		}
		self.amt.validate()?;
		if let Some(ref val) = self.fctv_dt { val.validate()? }
		if let Some(ref val) = self.drwr_agt { val.validate()? }
		if let Some(ref val) = self.drwr_agt_acct { val.validate()? }
		if let Some(ref val) = self.pyee { val.validate()? }
		if let Some(ref val) = self.pyee_acct { val.validate()? }
		self.chq_cxl_or_stop_sts.validate()?;
		Ok(())
	}
}


// Cheque19 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Cheque19 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChqTp", skip_serializing_if = "Option::is_none") )]
	pub chq_tp: Option<ChequeType2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChqNb", skip_serializing_if = "Option::is_none") )]
	pub chq_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChqFr", skip_serializing_if = "Option::is_none") )]
	pub chq_fr: Option<NameAndAddress18>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DlvryMtd", skip_serializing_if = "Option::is_none") )]
	pub dlvry_mtd: Option<ChequeDeliveryMethod1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DlvrTo", skip_serializing_if = "Option::is_none") )]
	pub dlvr_to: Option<NameAndAddress18>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrPrty", skip_serializing_if = "Option::is_none") )]
	pub instr_prty: Option<Priority2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChqMtrtyDt", skip_serializing_if = "Option::is_none") )]
	pub chq_mtrty_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrmsCd", skip_serializing_if = "Option::is_none") )]
	pub frms_cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MemoFld", skip_serializing_if = "Option::is_none") )]
	pub memo_fld: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RgnlClrZone", skip_serializing_if = "Option::is_none") )]
	pub rgnl_clr_zone: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtLctn", skip_serializing_if = "Option::is_none") )]
	pub prt_lctn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sgntr", skip_serializing_if = "Option::is_none") )]
	pub sgntr: Option<Vec<String>>,
}

impl Cheque19 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.chq_tp { val.validate()? }
		if let Some(ref val) = self.chq_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "chq_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "chq_nb exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.chq_fr { val.validate()? }
		if let Some(ref val) = self.dlvry_mtd { val.validate()? }
		if let Some(ref val) = self.dlvr_to { val.validate()? }
		if let Some(ref val) = self.instr_prty { val.validate()? }
		if let Some(ref val) = self.frms_cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "frms_cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "frms_cd exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref vec) = self.memo_fld {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "memo_fld is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 35 {
					return Err(ValidationError::new(1002, "memo_fld exceeds the maximum length of 35".to_string()));
				}
			}
		}
		if let Some(ref val) = self.rgnl_clr_zone {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rgnl_clr_zone is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "rgnl_clr_zone exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.prt_lctn {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prt_lctn is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prt_lctn exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref vec) = self.sgntr {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "sgntr is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 70 {
					return Err(ValidationError::new(1002, "sgntr exceeds the maximum length of 70".to_string()));
				}
			}
		}
		Ok(())
	}
}


// Cheque20 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Cheque20 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrId", skip_serializing_if = "Option::is_none") )]
	pub instr_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlInstrId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_instr_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChqNb") )]
	pub chq_nb: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IsseDt") )]
	pub isse_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StlDt", skip_serializing_if = "Option::is_none") )]
	pub stl_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FctvDt", skip_serializing_if = "Option::is_none") )]
	pub fctv_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DrwrAgt", skip_serializing_if = "Option::is_none") )]
	pub drwr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DrwrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub drwr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pyee", skip_serializing_if = "Option::is_none") )]
	pub pyee: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PyeeAcct", skip_serializing_if = "Option::is_none") )]
	pub pyee_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChqCxlOrStopRsn", skip_serializing_if = "Option::is_none") )]
	pub chq_cxl_or_stop_rsn: Option<ChequeCancellationReason1>,
}

impl Cheque20 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.instr_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "instr_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "instr_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_instr_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_instr_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_instr_id exceeds the maximum length of 35".to_string()));
			}
		}
		if self.chq_nb.chars().count() < 1 {
			return Err(ValidationError::new(1001, "chq_nb is shorter than the minimum length of 1".to_string()));
		}
		if self.chq_nb.chars().count() > 35 {
			return Err(ValidationError::new(1002, "chq_nb exceeds the maximum length of 35".to_string()));
		}
		self.amt.validate()?;
		if let Some(ref val) = self.fctv_dt { val.validate()? }
		if let Some(ref val) = self.drwr_agt { val.validate()? }
		if let Some(ref val) = self.drwr_agt_acct { val.validate()? }
		if let Some(ref val) = self.pyee { val.validate()? }
		if let Some(ref val) = self.pyee_acct { val.validate()? }
		if let Some(ref val) = self.chq_cxl_or_stop_rsn { val.validate()? }
		Ok(())
	}
}


// Cheque4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Cheque4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PyeeId") )]
	pub pyee_id: NameAndAddress5,
}

impl Cheque4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pyee_id.validate()?;
		Ok(())
	}
}


// ChequeCancellationReason1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ChequeCancellationReason1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Orgtr", skip_serializing_if = "Option::is_none") )]
	pub orgtr: Option<ChequePartyRole1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn") )]
	pub rsn: ChequeCancellationReason1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
}

impl ChequeCancellationReason1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgtr { val.validate()? }
		self.rsn.validate()?;
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// ChequeCancellationReason1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ChequeCancellationReason1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl ChequeCancellationReason1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// ChequeCancellationStatus1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ChequeCancellationStatus1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Orgtr", skip_serializing_if = "Option::is_none") )]
	pub orgtr: Option<ChequePartyRole1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts") )]
	pub sts: ChequeCancellationStatus1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
}

impl ChequeCancellationStatus1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgtr { val.validate()? }
		self.sts.validate()?;
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// ChequeCancellationStatus1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ChequeCancellationStatus1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl ChequeCancellationStatus1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// ChequeDelivery1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ChequeDelivery1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "MLDB") )]
	CodeMLDB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MLCD") )]
	CodeMLCD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MLFA") )]
	CodeMLFA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CRDB") )]
	CodeCRDB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CRCD") )]
	CodeCRCD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CRFA") )]
	CodeCRFA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PUDB") )]
	CodePUDB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PUCD") )]
	CodePUCD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PUFA") )]
	CodePUFA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RGDB") )]
	CodeRGDB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RGCD") )]
	CodeRGCD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RGFA") )]
	CodeRGFA,
}

impl ChequeDelivery1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ChequeDeliveryMethod1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ChequeDeliveryMethod1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<ChequeDelivery1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl ChequeDeliveryMethod1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// ChequePartyRole1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ChequePartyRole1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "DWEA") )]
	CodeDWEA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DWRA") )]
	CodeDWRA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PAYE") )]
	CodePAYE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PAYR") )]
	CodePAYR,
}

impl ChequePartyRole1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ChequeType2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ChequeType2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CCHQ") )]
	CodeCCHQ,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CCCH") )]
	CodeCCCH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BCHQ") )]
	CodeBCHQ,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DRFT") )]
	CodeDRFT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ELDR") )]
	CodeELDR,
}

impl ChequeType2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CitizenshipInformation1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CitizenshipInformation1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ntlty") )]
	pub ntlty: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MnrInd", skip_serializing_if = "Option::is_none") )]
	pub mnr_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StartDt", skip_serializing_if = "Option::is_none") )]
	pub start_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndDt", skip_serializing_if = "Option::is_none") )]
	pub end_dt: Option<String>,
}

impl CitizenshipInformation1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CitizenshipInformation2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CitizenshipInformation2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ntlty") )]
	pub ntlty: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MnrInd") )]
	pub mnr_ind: bool,
}

impl CitizenshipInformation2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CivilStatus1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CivilStatus1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<CivilStatus1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl CivilStatus1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// CivilStatus1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CivilStatus1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "DIVO") )]
	CodeDIVO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LDIV") )]
	CodeLDIV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MARR") )]
	CodeMARR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SEPA") )]
	CodeSEPA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SING") )]
	CodeSING,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UNIO") )]
	CodeUNIO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WIDO") )]
	CodeWIDO,
}

impl CivilStatus1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ClaimNonReceipt3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ClaimNonReceipt3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtPrcd") )]
	pub dt_prcd: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlNxtAgt", skip_serializing_if = "Option::is_none") )]
	pub orgnl_nxt_agt: Option<BranchAndFinancialInstitutionIdentification8>,
}

impl ClaimNonReceipt3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgnl_nxt_agt { val.validate()? }
		Ok(())
	}
}


// ClaimNonReceipt3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ClaimNonReceipt3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Accptd", skip_serializing_if = "Option::is_none") )]
	pub accptd: Option<ClaimNonReceipt3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rjctd", skip_serializing_if = "Option::is_none") )]
	pub rjctd: Option<ClaimNonReceiptRejectReason1Choice>,
}

impl ClaimNonReceipt3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.accptd { val.validate()? }
		if let Some(ref val) = self.rjctd { val.validate()? }
		Ok(())
	}
}


// ClaimNonReceiptRejectReason1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ClaimNonReceiptRejectReason1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl ClaimNonReceiptRejectReason1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// ClassificationType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ClassificationType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClssfctnFinInstrm", skip_serializing_if = "Option::is_none") )]
	pub clssfctn_fin_instrm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AltrnClssfctn", skip_serializing_if = "Option::is_none") )]
	pub altrn_clssfctn: Option<GenericIdentification1>,
}

impl ClassificationType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.clssfctn_fin_instrm {
			let pattern = Regex::new("[A-Z]{6,6}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "clssfctn_fin_instrm does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.altrn_clssfctn { val.validate()? }
		Ok(())
	}
}


// ClassificationType2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ClassificationType2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClssfctnFinInstrm", skip_serializing_if = "Option::is_none") )]
	pub clssfctn_fin_instrm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmPdctTpCd", skip_serializing_if = "Option::is_none") )]
	pub fin_instrm_pdct_tp_cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AltrnClssfctn", skip_serializing_if = "Option::is_none") )]
	pub altrn_clssfctn: Option<Vec<GenericIdentification36>>,
}

impl ClassificationType2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.clssfctn_fin_instrm {
			let pattern = Regex::new("[A-Z]{6,6}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "clssfctn_fin_instrm does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.fin_instrm_pdct_tp_cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "fin_instrm_pdct_tp_cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "fin_instrm_pdct_tp_cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref vec) = self.altrn_clssfctn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// Cleared16Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Cleared16Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Clrd", skip_serializing_if = "Option::is_none") )]
	pub clrd: Option<ClearingPartyAndTime14>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NonClrd", skip_serializing_if = "Option::is_none") )]
	pub non_clrd: Option<NoReasonCode>,
}

impl Cleared16Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.clrd { val.validate()? }
		if let Some(ref val) = self.non_clrd { val.validate()? }
		Ok(())
	}
}


// Cleared23Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Cleared23Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Clrd", skip_serializing_if = "Option::is_none") )]
	pub clrd: Option<ClearingPartyAndTime21Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntndToClear", skip_serializing_if = "Option::is_none") )]
	pub intnd_to_clear: Option<ClearingPartyAndTime22Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NonClrd", skip_serializing_if = "Option::is_none") )]
	pub non_clrd: Option<ClearingExceptionOrExemption3Choice>,
}

impl Cleared23Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.clrd { val.validate()? }
		if let Some(ref val) = self.intnd_to_clear { val.validate()? }
		if let Some(ref val) = self.non_clrd { val.validate()? }
		Ok(())
	}
}


// Cleared4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Cleared4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Clrd", skip_serializing_if = "Option::is_none") )]
	pub clrd: Option<NoReasonCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NonClrd", skip_serializing_if = "Option::is_none") )]
	pub non_clrd: Option<NoReasonCode>,
}

impl Cleared4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.clrd { val.validate()? }
		if let Some(ref val) = self.non_clrd { val.validate()? }
		Ok(())
	}
}


// ClearedProduct1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ClearedProduct1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgVn") )]
	pub tradg_vn: Vec<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CCPPdctId") )]
	pub ccp_pdct_id: GenericIdentification168,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UvrslPdctId", skip_serializing_if = "Option::is_none") )]
	pub uvrsl_pdct_id: Option<GenericIdentification168>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pdct") )]
	pub pdct: Product1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OpnIntrst") )]
	pub opn_intrst: OpenInterest1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrdsClrd", skip_serializing_if = "Option::is_none") )]
	pub trds_clrd: Option<f64>,
}

impl ClearedProduct1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		for item in &self.tradg_vn {
			let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
			if !pattern.is_match(&item) {
				return Err(ValidationError::new(1005, "tradg_vn does not match the required pattern".to_string()));
			}
		}
		self.ccp_pdct_id.validate()?;
		if let Some(ref val) = self.uvrsl_pdct_id { val.validate()? }
		self.pdct.validate()?;
		self.opn_intrst.validate()?;
		if let Some(ref val) = self.trds_clrd {
			if *val < 0.000000 {
				return Err(ValidationError::new(1003, "trds_clrd is less than the minimum value of 0.000000".to_string()));
			}
		}
		Ok(())
	}
}


// ClearingAccount1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ClearingAccount1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctTp") )]
	pub acct_tp: ClearingAccountType3Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollAcctOwnr") )]
	pub coll_acct_ownr: Vec<CollateralAccount5>,
}

impl ClearingAccount1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.acct_tp.validate()?;
		for item in &self.coll_acct_ownr { item.validate()? }
		Ok(())
	}
}


// ClearingAccountType3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ClearingAccountType3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "NOSA") )]
	CodeNOSA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISEG") )]
	CodeISEG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HOUS") )]
	CodeHOUS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GOSA") )]
	CodeGOSA,
}

impl ClearingAccountType3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ClearingAccountType4Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ClearingAccountType4Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CLIE") )]
	CodeCLIE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HOUS") )]
	CodeHOUS,
}

impl ClearingAccountType4Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ClearingChannel2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ClearingChannel2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "RTGS") )]
	CodeRTGS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RTNS") )]
	CodeRTNS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MPNS") )]
	CodeMPNS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BOOK") )]
	CodeBOOK,
}

impl ClearingChannel2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ClearingExceptionOrExemption2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ClearingExceptionOrExemption2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgCtrPty") )]
	pub rptg_ctr_pty: NonClearingReason2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrCtrPty", skip_serializing_if = "Option::is_none") )]
	pub othr_ctr_pty: Option<NonClearingReason2>,
}

impl ClearingExceptionOrExemption2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.rptg_ctr_pty.validate()?;
		if let Some(ref val) = self.othr_ctr_pty { val.validate()? }
		Ok(())
	}
}


// ClearingExceptionOrExemption3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ClearingExceptionOrExemption3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<NoReasonCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPties", skip_serializing_if = "Option::is_none") )]
	pub ctr_pties: Option<ClearingExceptionOrExemption2>,
}

impl ClearingExceptionOrExemption3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rsn { val.validate()? }
		if let Some(ref val) = self.ctr_pties { val.validate()? }
		Ok(())
	}
}


// ClearingExemptionException1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ClearingExemptionException1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "COOP") )]
	CodeCOOP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ENDU") )]
	CodeENDU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AFFL") )]
	CodeAFFL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NOAL") )]
	CodeNOAL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NORE") )]
	CodeNORE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SMBK") )]
	CodeSMBK,
}

impl ClearingExemptionException1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ClearingMember1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ClearingMember1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: PartyIdentification118Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtQlty") )]
	pub cdt_qlty: CreditQuality1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtPrntId", skip_serializing_if = "Option::is_none") )]
	pub ultmt_prnt_id: Option<PartyIdentification118Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FutrsComssnMrchntInd") )]
	pub futrs_comssn_mrchnt_ind: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MmbshVldFr") )]
	pub mmbsh_vld_fr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MmbshVldTo", skip_serializing_if = "Option::is_none") )]
	pub mmbsh_vld_to: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SpnsrgClrMmbId", skip_serializing_if = "Option::is_none") )]
	pub spnsrg_clr_mmb_id: Option<PartyIdentification118Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrAcctOwnr") )]
	pub clr_acct_ownr: Vec<ClearingAccount1>,
}

impl ClearingMember1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.id.validate()?;
		self.cdt_qlty.validate()?;
		if let Some(ref val) = self.ultmt_prnt_id { val.validate()? }
		if let Some(ref val) = self.spnsrg_clr_mmb_id { val.validate()? }
		for item in &self.clr_acct_ownr { item.validate()? }
		Ok(())
	}
}


// ClearingObligationType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ClearingObligationType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "FLSE") )]
	CodeFLSE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UKWN") )]
	CodeUKWN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TRUE") )]
	CodeTRUE,
}

impl ClearingObligationType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ClearingPartyAndTime14 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ClearingPartyAndTime14 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CCP", skip_serializing_if = "Option::is_none") )]
	pub ccp: Option<OrganisationIdentification15Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrDtTm", skip_serializing_if = "Option::is_none") )]
	pub clr_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptTrckgNb", skip_serializing_if = "Option::is_none") )]
	pub rpt_trckg_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtflCd", skip_serializing_if = "Option::is_none") )]
	pub prtfl_cd: Option<String>,
}

impl ClearingPartyAndTime14 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ccp { val.validate()? }
		if let Some(ref val) = self.rpt_trckg_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rpt_trckg_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 52 {
				return Err(ValidationError::new(1002, "rpt_trckg_nb exceeds the maximum length of 52".to_string()));
			}
		}
		if let Some(ref val) = self.prtfl_cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtfl_cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 52 {
				return Err(ValidationError::new(1002, "prtfl_cd exceeds the maximum length of 52".to_string()));
			}
		}
		Ok(())
	}
}


// ClearingPartyAndTime21Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ClearingPartyAndTime21Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<NoReasonCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dtls", skip_serializing_if = "Option::is_none") )]
	pub dtls: Option<ClearingPartyAndTime22>,
}

impl ClearingPartyAndTime21Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rsn { val.validate()? }
		if let Some(ref val) = self.dtls { val.validate()? }
		Ok(())
	}
}


// ClearingPartyAndTime22 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ClearingPartyAndTime22 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CCP", skip_serializing_if = "Option::is_none") )]
	pub ccp: Option<OrganisationIdentification15Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrRctDtTm", skip_serializing_if = "Option::is_none") )]
	pub clr_rct_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrDtTm", skip_serializing_if = "Option::is_none") )]
	pub clr_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrIdr", skip_serializing_if = "Option::is_none") )]
	pub clr_idr: Option<UniqueTransactionIdentifier2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlIdr", skip_serializing_if = "Option::is_none") )]
	pub orgnl_idr: Option<UniqueTransactionIdentifier2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlTradRpstryIdr", skip_serializing_if = "Option::is_none") )]
	pub orgnl_trad_rpstry_idr: Option<OrganisationIdentification15Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrAcctOrgn", skip_serializing_if = "Option::is_none") )]
	pub clr_acct_orgn: Option<ClearingAccountType4Code>,
}

impl ClearingPartyAndTime22 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ccp { val.validate()? }
		if let Some(ref val) = self.clr_idr { val.validate()? }
		if let Some(ref val) = self.orgnl_idr { val.validate()? }
		if let Some(ref val) = self.orgnl_trad_rpstry_idr { val.validate()? }
		if let Some(ref val) = self.clr_acct_orgn { val.validate()? }
		Ok(())
	}
}


// ClearingPartyAndTime22Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ClearingPartyAndTime22Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<NoReasonCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dtls", skip_serializing_if = "Option::is_none") )]
	pub dtls: Option<ClearingPartyAndTime23>,
}

impl ClearingPartyAndTime22Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rsn { val.validate()? }
		if let Some(ref val) = self.dtls { val.validate()? }
		Ok(())
	}
}


// ClearingPartyAndTime23 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ClearingPartyAndTime23 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CCP", skip_serializing_if = "Option::is_none") )]
	pub ccp: Option<OrganisationIdentification15Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrRctDtTm", skip_serializing_if = "Option::is_none") )]
	pub clr_rct_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrDtTm", skip_serializing_if = "Option::is_none") )]
	pub clr_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrIdr", skip_serializing_if = "Option::is_none") )]
	pub clr_idr: Option<UniqueTransactionIdentifier1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlIdr", skip_serializing_if = "Option::is_none") )]
	pub orgnl_idr: Option<UniqueTransactionIdentifier1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlTradRpstryIdr", skip_serializing_if = "Option::is_none") )]
	pub orgnl_trad_rpstry_idr: Option<OrganisationIdentification15Choice>,
}

impl ClearingPartyAndTime23 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ccp { val.validate()? }
		if let Some(ref val) = self.clr_idr { val.validate()? }
		if let Some(ref val) = self.orgnl_idr { val.validate()? }
		if let Some(ref val) = self.orgnl_trad_rpstry_idr { val.validate()? }
		Ok(())
	}
}


// ClearingSystemIdentification2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ClearingSystemIdentification2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl ClearingSystemIdentification2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 5 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 5".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// ClearingSystemIdentification3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ClearingSystemIdentification3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl ClearingSystemIdentification3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 3 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 3".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// ClearingSystemMemberIdentification2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ClearingSystemMemberIdentification2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrSysId", skip_serializing_if = "Option::is_none") )]
	pub clr_sys_id: Option<ClearingSystemIdentification2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MmbId") )]
	pub mmb_id: String,
}

impl ClearingSystemMemberIdentification2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.clr_sys_id { val.validate()? }
		if self.mmb_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "mmb_id is shorter than the minimum length of 1".to_string()));
		}
		if self.mmb_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "mmb_id exceeds the maximum length of 35".to_string()));
		}
		Ok(())
	}
}


// ClearingSystemMemberIdentification4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ClearingSystemMemberIdentification4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "USCHU", skip_serializing_if = "Option::is_none") )]
	pub uschu: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NZNCC", skip_serializing_if = "Option::is_none") )]
	pub nzncc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IENSC", skip_serializing_if = "Option::is_none") )]
	pub iensc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GBSC", skip_serializing_if = "Option::is_none") )]
	pub gbsc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "USCH", skip_serializing_if = "Option::is_none") )]
	pub usch: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CHBC", skip_serializing_if = "Option::is_none") )]
	pub chbc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "USFW", skip_serializing_if = "Option::is_none") )]
	pub usfw: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PTNCC", skip_serializing_if = "Option::is_none") )]
	pub ptncc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RUCB", skip_serializing_if = "Option::is_none") )]
	pub rucb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ITNCC", skip_serializing_if = "Option::is_none") )]
	pub itncc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ATBLZ", skip_serializing_if = "Option::is_none") )]
	pub atblz: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CACPA", skip_serializing_if = "Option::is_none") )]
	pub cacpa: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CHSIC", skip_serializing_if = "Option::is_none") )]
	pub chsic: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DEBLZ", skip_serializing_if = "Option::is_none") )]
	pub deblz: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ESNCC", skip_serializing_if = "Option::is_none") )]
	pub esncc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ZANCC", skip_serializing_if = "Option::is_none") )]
	pub zancc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HKNCC", skip_serializing_if = "Option::is_none") )]
	pub hkncc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AUBSBx", skip_serializing_if = "Option::is_none") )]
	pub aubs_bx: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AUBSBs", skip_serializing_if = "Option::is_none") )]
	pub aubs_bs: Option<String>,
}

impl ClearingSystemMemberIdentification4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.uschu {
			let pattern = Regex::new("CH[0-9]{6,6}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "uschu does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.nzncc {
			let pattern = Regex::new("NZ[0-9]{6,6}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "nzncc does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.iensc {
			let pattern = Regex::new("IE[0-9]{6,6}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "iensc does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.gbsc {
			let pattern = Regex::new("SC[0-9]{6,6}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "gbsc does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.usch {
			let pattern = Regex::new("CP[0-9]{4,4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "usch does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.chbc {
			let pattern = Regex::new("SW[0-9]{3,5}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "chbc does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.usfw {
			let pattern = Regex::new("FW[0-9]{9,9}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "usfw does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.ptncc {
			let pattern = Regex::new("PT[0-9]{8,8}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ptncc does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.rucb {
			let pattern = Regex::new("RU[0-9]{9,9}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "rucb does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.itncc {
			let pattern = Regex::new("IT[0-9]{10,10}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "itncc does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.atblz {
			let pattern = Regex::new("AT[0-9]{5,5}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "atblz does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.cacpa {
			let pattern = Regex::new("CA[0-9]{9,9}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "cacpa does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.chsic {
			let pattern = Regex::new("SW[0-9]{6,6}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "chsic does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.deblz {
			let pattern = Regex::new("BL[0-9]{8,8}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "deblz does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.esncc {
			let pattern = Regex::new("ES[0-9]{8,9}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "esncc does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.zancc {
			let pattern = Regex::new("ZA[0-9]{6,6}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "zancc does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.hkncc {
			let pattern = Regex::new("HK[0-9]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "hkncc does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.aubs_bx {
			let pattern = Regex::new("AU[0-9]{6,6}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "aubs_bx does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.aubs_bs {
			let pattern = Regex::new("AU[0-9]{6,6}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "aubs_bs does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// ClosedStatusReason1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ClosedStatusReason1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd") )]
	pub cd: ClosedStatusReason2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
}

impl ClosedStatusReason1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.cd.validate()?;
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 350".to_string()));
			}
		}
		Ok(())
	}
}


// ClosedStatusReason1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ClosedStatusReason1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NoSpcfdRsn", skip_serializing_if = "Option::is_none") )]
	pub no_spcfd_rsn: Option<NoReasonCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<Vec<ClosedStatusReason1>>,
}

impl ClosedStatusReason1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.no_spcfd_rsn { val.validate()? }
		if let Some(ref vec) = self.rsn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// ClosedStatusReason1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ClosedStatusReason1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ASIN") )]
	CodeASIN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CLIN") )]
	CodeCLIN,
}

impl ClosedStatusReason1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ClosedStatusReason2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ClosedStatusReason2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<ClosedStatusReason1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification36>,
}

impl ClosedStatusReason2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// ClosurePendingStatusReason1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ClosurePendingStatusReason1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd") )]
	pub cd: ClosurePendingStatusReason2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
}

impl ClosurePendingStatusReason1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.cd.validate()?;
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 350".to_string()));
			}
		}
		Ok(())
	}
}


// ClosurePendingStatusReason1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ClosurePendingStatusReason1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NoSpcfdRsn", skip_serializing_if = "Option::is_none") )]
	pub no_spcfd_rsn: Option<NoReasonCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<Vec<ClosurePendingStatusReason1>>,
}

impl ClosurePendingStatusReason1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.no_spcfd_rsn { val.validate()? }
		if let Some(ref vec) = self.rsn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// ClosurePendingStatusReason1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ClosurePendingStatusReason1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CLOS") )]
	CodeCLOS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PEND") )]
	CodePEND,
}

impl ClosurePendingStatusReason1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ClosurePendingStatusReason2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ClosurePendingStatusReason2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<ClosurePendingStatusReason1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification36>,
}

impl ClosurePendingStatusReason2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// ClosureReason2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ClosureReason2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<SystemClosureReason1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl ClosureReason2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// CodeOrProprietary1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CodeOrProprietary1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification13>,
}

impl CodeOrProprietary1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// Collateral18 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Collateral18 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Valtn") )]
	pub valtn: SecuredCollateral2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Hrcut", skip_serializing_if = "Option::is_none") )]
	pub hrcut: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SpclCollInd", skip_serializing_if = "Option::is_none") )]
	pub spcl_coll_ind: Option<SpecialCollateral2Code>,
}

impl Collateral18 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.valtn.validate()?;
		if let Some(ref val) = self.spcl_coll_ind { val.validate()? }
		Ok(())
	}
}


// Collateral1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum Collateral1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "COLL") )]
	CodeCOLL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NCOL") )]
	CodeNCOL,
}

impl Collateral1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Collateral52 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Collateral52 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollValDt", skip_serializing_if = "Option::is_none") )]
	pub coll_val_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AsstTp", skip_serializing_if = "Option::is_none") )]
	pub asst_tp: Option<CollateralType21>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NetXpsrCollstnInd", skip_serializing_if = "Option::is_none") )]
	pub net_xpsr_collstn_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BsktIdr", skip_serializing_if = "Option::is_none") )]
	pub bskt_idr: Option<SecurityIdentification26Choice>,
}

impl Collateral52 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.asst_tp { val.validate()? }
		if let Some(ref val) = self.bskt_idr { val.validate()? }
		Ok(())
	}
}


// CollateralAccount4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CollateralAccount4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: GenericIdentification165,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AsstHldg") )]
	pub asst_hldg: Vec<AssetHolding1>,
}

impl CollateralAccount4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.id.validate()?;
		for item in &self.asst_hldg { item.validate()? }
		Ok(())
	}
}


// CollateralAccount5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CollateralAccount5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: PartyIdentification118Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdMrgnAcct") )]
	pub rltd_mrgn_acct: Vec<MarginAccount1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TitlTrfCollArrgmnt", skip_serializing_if = "Option::is_none") )]
	pub titl_trf_coll_arrgmnt: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollSgrtnByVal", skip_serializing_if = "Option::is_none") )]
	pub coll_sgrtn_by_val: Option<bool>,
}

impl CollateralAccount5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.id.validate()?;
		for item in &self.rltd_mrgn_acct { item.validate()? }
		Ok(())
	}
}


// CollateralAccountType3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CollateralAccountType3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "MGIN") )]
	CodeMGIN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DFLT") )]
	CodeDFLT,
}

impl CollateralAccountType3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CollateralData33 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CollateralData33 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NetXpsrCollstnInd", skip_serializing_if = "Option::is_none") )]
	pub net_xpsr_collstn_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CmpntTp", skip_serializing_if = "Option::is_none") )]
	pub cmpnt_tp: Option<CollateralType6Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshCollCcy", skip_serializing_if = "Option::is_none") )]
	pub csh_coll_ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PricCcy", skip_serializing_if = "Option::is_none") )]
	pub pric_ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Qlty", skip_serializing_if = "Option::is_none") )]
	pub qlty: Option<CollateralQualityType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mtrty", skip_serializing_if = "Option::is_none") )]
	pub mtrty: Option<ContractTerm6Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IssrJursdctn", skip_serializing_if = "Option::is_none") )]
	pub issr_jursdctn: Option<IssuerJurisdiction1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<SecuritiesLendingType3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradRpstry", skip_serializing_if = "Option::is_none") )]
	pub trad_rpstry: Option<OrganisationIdentification15Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RcncltnFlg", skip_serializing_if = "Option::is_none") )]
	pub rcncltn_flg: Option<ReconciliationFlag2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RinvstdCsh", skip_serializing_if = "Option::is_none") )]
	pub rinvstd_csh: Option<ReinvestedCashTypeAndAmount2>,
}

impl CollateralData33 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cmpnt_tp { val.validate()? }
		if let Some(ref val) = self.csh_coll_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "csh_coll_ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.pric_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "pric_ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.qlty { val.validate()? }
		if let Some(ref val) = self.mtrty { val.validate()? }
		if let Some(ref val) = self.issr_jursdctn { val.validate()? }
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.trad_rpstry { val.validate()? }
		if let Some(ref val) = self.rcncltn_flg { val.validate()? }
		if let Some(ref val) = self.rinvstd_csh { val.validate()? }
		Ok(())
	}
}


// CollateralData35 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CollateralData35 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AsstTp", skip_serializing_if = "Option::is_none") )]
	pub asst_tp: Option<CollateralType21>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NetXpsrCollstnInd", skip_serializing_if = "Option::is_none") )]
	pub net_xpsr_collstn_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BsktIdr", skip_serializing_if = "Option::is_none") )]
	pub bskt_idr: Option<SecurityIdentification26Choice>,
}

impl CollateralData35 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.asst_tp { val.validate()? }
		if let Some(ref val) = self.bskt_idr { val.validate()? }
		Ok(())
	}
}


// CollateralDeliveryMethod1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CollateralDeliveryMethod1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "SICA") )]
	CodeSICA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SIUR") )]
	CodeSIUR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TTCA") )]
	CodeTTCA,
}

impl CollateralDeliveryMethod1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CollateralFlag13Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CollateralFlag13Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Collsd", skip_serializing_if = "Option::is_none") )]
	pub collsd: Option<CollaterisedData12>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Uncollsd", skip_serializing_if = "Option::is_none") )]
	pub uncollsd: Option<NoReasonCode>,
}

impl CollateralFlag13Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.collsd { val.validate()? }
		if let Some(ref val) = self.uncollsd { val.validate()? }
		Ok(())
	}
}


// CollateralMarginCorrection6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CollateralMarginCorrection6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechRcrdId", skip_serializing_if = "Option::is_none") )]
	pub tech_rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgDtTm") )]
	pub rptg_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EvtDt") )]
	pub evt_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPty") )]
	pub ctr_pty: Counterparty39,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollPrtflId") )]
	pub coll_prtfl_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstdMrgnOrColl", skip_serializing_if = "Option::is_none") )]
	pub pstd_mrgn_or_coll: Option<PostedMarginOrCollateral4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RcvdMrgnOrColl", skip_serializing_if = "Option::is_none") )]
	pub rcvd_mrgn_or_coll: Option<ReceivedMarginOrCollateral4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl CollateralMarginCorrection6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tech_rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tech_rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "tech_rcrd_id exceeds the maximum length of 140".to_string()));
			}
		}
		self.ctr_pty.validate()?;
		if self.coll_prtfl_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "coll_prtfl_id is shorter than the minimum length of 1".to_string()));
		}
		if self.coll_prtfl_id.chars().count() > 52 {
			return Err(ValidationError::new(1002, "coll_prtfl_id exceeds the maximum length of 52".to_string()));
		}
		if let Some(ref val) = self.pstd_mrgn_or_coll { val.validate()? }
		if let Some(ref val) = self.rcvd_mrgn_or_coll { val.validate()? }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// CollateralMarginError4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CollateralMarginError4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechRcrdId", skip_serializing_if = "Option::is_none") )]
	pub tech_rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgDtTm") )]
	pub rptg_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPty") )]
	pub ctr_pty: Counterparty39,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollPrtflId") )]
	pub coll_prtfl_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl CollateralMarginError4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tech_rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tech_rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "tech_rcrd_id exceeds the maximum length of 140".to_string()));
			}
		}
		self.ctr_pty.validate()?;
		if self.coll_prtfl_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "coll_prtfl_id is shorter than the minimum length of 1".to_string()));
		}
		if self.coll_prtfl_id.chars().count() > 52 {
			return Err(ValidationError::new(1002, "coll_prtfl_id exceeds the maximum length of 52".to_string()));
		}
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// CollateralMarginMarginUpdate5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CollateralMarginMarginUpdate5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechRcrdId", skip_serializing_if = "Option::is_none") )]
	pub tech_rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgDtTm") )]
	pub rptg_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EvtDt") )]
	pub evt_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPty", skip_serializing_if = "Option::is_none") )]
	pub ctr_pty: Option<Counterparty39>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollPrtflId") )]
	pub coll_prtfl_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstdMrgnOrColl", skip_serializing_if = "Option::is_none") )]
	pub pstd_mrgn_or_coll: Option<PostedMarginOrCollateral4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RcvdMrgnOrColl", skip_serializing_if = "Option::is_none") )]
	pub rcvd_mrgn_or_coll: Option<ReceivedMarginOrCollateral4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl CollateralMarginMarginUpdate5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tech_rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tech_rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "tech_rcrd_id exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.ctr_pty { val.validate()? }
		if self.coll_prtfl_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "coll_prtfl_id is shorter than the minimum length of 1".to_string()));
		}
		if self.coll_prtfl_id.chars().count() > 52 {
			return Err(ValidationError::new(1002, "coll_prtfl_id exceeds the maximum length of 52".to_string()));
		}
		if let Some(ref val) = self.pstd_mrgn_or_coll { val.validate()? }
		if let Some(ref val) = self.rcvd_mrgn_or_coll { val.validate()? }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// CollateralMarginNew10 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CollateralMarginNew10 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechRcrdId", skip_serializing_if = "Option::is_none") )]
	pub tech_rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgDtTm") )]
	pub rptg_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EvtDt") )]
	pub evt_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPty") )]
	pub ctr_pty: Counterparty39,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollPrtflId") )]
	pub coll_prtfl_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstdMrgnOrColl", skip_serializing_if = "Option::is_none") )]
	pub pstd_mrgn_or_coll: Option<PostedMarginOrCollateral4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RcvdMrgnOrColl", skip_serializing_if = "Option::is_none") )]
	pub rcvd_mrgn_or_coll: Option<ReceivedMarginOrCollateral4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RcncltnFlg", skip_serializing_if = "Option::is_none") )]
	pub rcncltn_flg: Option<ReconciliationFlag2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctMod") )]
	pub ctrct_mod: ContractModification3,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl CollateralMarginNew10 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tech_rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tech_rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "tech_rcrd_id exceeds the maximum length of 140".to_string()));
			}
		}
		self.ctr_pty.validate()?;
		if self.coll_prtfl_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "coll_prtfl_id is shorter than the minimum length of 1".to_string()));
		}
		if self.coll_prtfl_id.chars().count() > 52 {
			return Err(ValidationError::new(1002, "coll_prtfl_id exceeds the maximum length of 52".to_string()));
		}
		if let Some(ref val) = self.pstd_mrgn_or_coll { val.validate()? }
		if let Some(ref val) = self.rcvd_mrgn_or_coll { val.validate()? }
		if let Some(ref val) = self.rcncltn_flg { val.validate()? }
		self.ctrct_mod.validate()?;
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// CollateralMatchingCriteria6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CollateralMatchingCriteria6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "UncollsdFlg", skip_serializing_if = "Option::is_none") )]
	pub uncollsd_flg: Option<CompareTrueFalseIndicator3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NetXpsrCollstnInd", skip_serializing_if = "Option::is_none") )]
	pub net_xpsr_collstn_ind: Option<CompareTrueFalseIndicator3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollValDt", skip_serializing_if = "Option::is_none") )]
	pub coll_val_dt: Option<CompareDate3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AsstTp", skip_serializing_if = "Option::is_none") )]
	pub asst_tp: Option<SecurityCommodityCash4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BsktIdr", skip_serializing_if = "Option::is_none") )]
	pub bskt_idr: Option<CompareSecurityIdentification4>,
}

impl CollateralMatchingCriteria6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.uncollsd_flg { val.validate()? }
		if let Some(ref val) = self.net_xpsr_collstn_ind { val.validate()? }
		if let Some(ref val) = self.coll_val_dt { val.validate()? }
		if let Some(ref val) = self.asst_tp { val.validate()? }
		if let Some(ref val) = self.bskt_idr { val.validate()? }
		Ok(())
	}
}


// CollateralPool1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CollateralPool1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "NOPL") )]
	CodeNOPL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "POOL") )]
	CodePOOL,
}

impl CollateralPool1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CollateralPortfolioCode5Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CollateralPortfolioCode5Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtfl", skip_serializing_if = "Option::is_none") )]
	pub prtfl: Option<PortfolioCode3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MrgnPrtflCd", skip_serializing_if = "Option::is_none") )]
	pub mrgn_prtfl_cd: Option<MarginPortfolio3>,
}

impl CollateralPortfolioCode5Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.prtfl { val.validate()? }
		if let Some(ref val) = self.mrgn_prtfl_cd { val.validate()? }
		Ok(())
	}
}


// CollateralPortfolioCode6Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CollateralPortfolioCode6Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtfl", skip_serializing_if = "Option::is_none") )]
	pub prtfl: Option<PortfolioCode3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MrgnPrtflCd", skip_serializing_if = "Option::is_none") )]
	pub mrgn_prtfl_cd: Option<MarginPortfolio4>,
}

impl CollateralPortfolioCode6Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.prtfl { val.validate()? }
		if let Some(ref val) = self.mrgn_prtfl_cd { val.validate()? }
		Ok(())
	}
}


// CollateralQualityType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CollateralQualityType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "INVG") )]
	CodeINVG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NIVG") )]
	CodeNIVG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NOTR") )]
	CodeNOTR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NOAP") )]
	CodeNOAP,
}

impl CollateralQualityType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CollateralRole1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CollateralRole1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "GIVE") )]
	CodeGIVE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TAKE") )]
	CodeTAKE,
}

impl CollateralRole1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CollateralType19 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CollateralType19 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Scty", skip_serializing_if = "Option::is_none") )]
	pub scty: Option<Vec<SecurityReuseData1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Csh", skip_serializing_if = "Option::is_none") )]
	pub csh: Option<Vec<CashReuseData1>>,
}

impl CollateralType19 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.scty { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.csh { for item in vec { item.validate()? } }
		Ok(())
	}
}


// CollateralType21 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CollateralType21 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Scty", skip_serializing_if = "Option::is_none") )]
	pub scty: Option<Vec<Security52>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Csh", skip_serializing_if = "Option::is_none") )]
	pub csh: Option<Vec<AmountHaircutMargin1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cmmdty", skip_serializing_if = "Option::is_none") )]
	pub cmmdty: Option<Vec<Commodity43>>,
}

impl CollateralType21 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.scty { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.csh { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.cmmdty { for item in vec { item.validate()? } }
		Ok(())
	}
}


// CollateralType22Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CollateralType22Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "GnlColl", skip_serializing_if = "Option::is_none") )]
	pub gnl_coll: Option<GeneralCollateral4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SpcfcColl", skip_serializing_if = "Option::is_none") )]
	pub spcfc_coll: Option<SpecificCollateral3>,
}

impl CollateralType22Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.gnl_coll { val.validate()? }
		if let Some(ref val) = self.spcfc_coll { val.validate()? }
		Ok(())
	}
}


// CollateralType6Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CollateralType6Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "GBBK") )]
	CodeGBBK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BOND") )]
	CodeBOND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CASH") )]
	CodeCASH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "COMM") )]
	CodeCOMM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INSU") )]
	CodeINSU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LCRE") )]
	CodeLCRE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PHYS") )]
	CodePHYS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SECU") )]
	CodeSECU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "STCF") )]
	CodeSTCF,
}

impl CollateralType6Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CollateralValuation6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CollateralValuation6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NmnlAmt", skip_serializing_if = "Option::is_none") )]
	pub nmnl_amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISIN") )]
	pub isin: String,
}

impl CollateralValuation6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nmnl_amt { val.validate()? }
		let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
		if !pattern.is_match(&self.isin) {
			return Err(ValidationError::new(1005, "isin does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// CollateralValuation7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CollateralValuation7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PoolSts") )]
	pub pool_sts: CollateralPool1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sctr") )]
	pub sctr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NmnlAmt", skip_serializing_if = "Option::is_none") )]
	pub nmnl_amt: Option<ActiveCurrencyAndAmount>,
}

impl CollateralValuation7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pool_sts.validate()?;
		let pattern = Regex::new("[A-Z]{6,6}").unwrap();
		if !pattern.is_match(&self.tp) {
			return Err(ValidationError::new(1005, "tp does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.nmnl_amt { val.validate()? }
		Ok(())
	}
}


// CollateralisationType3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CollateralisationType3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "FLCL") )]
	CodeFLCL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OWCL") )]
	CodeOWCL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OWC1") )]
	CodeOWC1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OWC2") )]
	CodeOWC2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OWP1") )]
	CodeOWP1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OWP2") )]
	CodeOWP2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRCL") )]
	CodePRCL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRC1") )]
	CodePRC1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRC2") )]
	CodePRC2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UNCL") )]
	CodeUNCL,
}

impl CollateralisationType3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CollaterisedData12 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CollaterisedData12 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollValDt", skip_serializing_if = "Option::is_none") )]
	pub coll_val_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AsstTp", skip_serializing_if = "Option::is_none") )]
	pub asst_tp: Option<CollateralType21>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NetXpsrCollstnInd", skip_serializing_if = "Option::is_none") )]
	pub net_xpsr_collstn_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BsktIdr", skip_serializing_if = "Option::is_none") )]
	pub bskt_idr: Option<SecurityIdentification26Choice>,
}

impl CollaterisedData12 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.asst_tp { val.validate()? }
		if let Some(ref val) = self.bskt_idr { val.validate()? }
		Ok(())
	}
}


// Commission21 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Commission21 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ComssnTp") )]
	pub comssn_tp: CommissionType5Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ComssnApld") )]
	pub comssn_apld: AmountOrRate3Choice,
}

impl Commission21 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.comssn_tp.validate()?;
		self.comssn_apld.validate()?;
		Ok(())
	}
}


// CommissionType5Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CommissionType5Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<CommissionType6Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl CommissionType5Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// CommissionType6Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CommissionType6Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "FEND") )]
	CodeFEND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BEND") )]
	CodeBEND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CDPL") )]
	CodeCDPL,
}

impl CommissionType6Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Commodity2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Commodity2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktVal") )]
	pub mkt_val: ActiveCurrencyAnd24Amount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CmmdtyTp") )]
	pub cmmdty_tp: AssetClassDetailedSubProductType1Choice,
}

impl Commodity2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.mkt_val.validate()?;
		self.cmmdty_tp.validate()?;
		Ok(())
	}
}


// Commodity42 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Commodity42 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Clssfctn", skip_serializing_if = "Option::is_none") )]
	pub clssfctn: Option<CompareCommodityAssetClass3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Qty", skip_serializing_if = "Option::is_none") )]
	pub qty: Option<CompareDecimalNumber3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnitPric", skip_serializing_if = "Option::is_none") )]
	pub unit_pric: Option<CompareUnitPrice6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktVal", skip_serializing_if = "Option::is_none") )]
	pub mkt_val: Option<CompareAmountAndDirection2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnitOfMeasr", skip_serializing_if = "Option::is_none") )]
	pub unit_of_measr: Option<CompareUnitOfMeasure3>,
}

impl Commodity42 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.clssfctn { val.validate()? }
		if let Some(ref val) = self.qty { val.validate()? }
		if let Some(ref val) = self.unit_pric { val.validate()? }
		if let Some(ref val) = self.mkt_val { val.validate()? }
		if let Some(ref val) = self.unit_of_measr { val.validate()? }
		Ok(())
	}
}


// Commodity43 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Commodity43 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Clssfctn", skip_serializing_if = "Option::is_none") )]
	pub clssfctn: Option<AssetClassCommodity5Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Qty", skip_serializing_if = "Option::is_none") )]
	pub qty: Option<Quantity17>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnitPric", skip_serializing_if = "Option::is_none") )]
	pub unit_pric: Option<SecuritiesTransactionPrice19Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktVal", skip_serializing_if = "Option::is_none") )]
	pub mkt_val: Option<AmountAndDirection53>,
}

impl Commodity43 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.clssfctn { val.validate()? }
		if let Some(ref val) = self.qty { val.validate()? }
		if let Some(ref val) = self.unit_pric { val.validate()? }
		if let Some(ref val) = self.mkt_val { val.validate()? }
		Ok(())
	}
}


// CommodityDerivative2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CommodityDerivative2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Frght", skip_serializing_if = "Option::is_none") )]
	pub frght: Option<CommodityDerivative5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nrgy", skip_serializing_if = "Option::is_none") )]
	pub nrgy: Option<CommodityDerivative6>,
}

impl CommodityDerivative2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.frght { val.validate()? }
		if let Some(ref val) = self.nrgy { val.validate()? }
		Ok(())
	}
}


// CommodityDerivative4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CommodityDerivative4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClssSpcfc", skip_serializing_if = "Option::is_none") )]
	pub clss_spcfc: Option<CommodityDerivative2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtnlCcy") )]
	pub ntnl_ccy: String,
}

impl CommodityDerivative4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.clss_spcfc { val.validate()? }
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.ntnl_ccy) {
			return Err(ValidationError::new(1005, "ntnl_ccy does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// CommodityDerivative5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CommodityDerivative5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sz") )]
	pub sz: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AvrgTmChrtr") )]
	pub avrg_tm_chrtr: String,
}

impl CommodityDerivative5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.sz.chars().count() < 1 {
			return Err(ValidationError::new(1001, "sz is shorter than the minimum length of 1".to_string()));
		}
		if self.sz.chars().count() > 25 {
			return Err(ValidationError::new(1002, "sz exceeds the maximum length of 25".to_string()));
		}
		if self.avrg_tm_chrtr.chars().count() < 1 {
			return Err(ValidationError::new(1001, "avrg_tm_chrtr is shorter than the minimum length of 1".to_string()));
		}
		if self.avrg_tm_chrtr.chars().count() > 25 {
			return Err(ValidationError::new(1002, "avrg_tm_chrtr exceeds the maximum length of 25".to_string()));
		}
		Ok(())
	}
}


// CommodityDerivative6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CommodityDerivative6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmLctn") )]
	pub sttlm_lctn: String,
}

impl CommodityDerivative6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.sttlm_lctn.chars().count() < 1 {
			return Err(ValidationError::new(1001, "sttlm_lctn is shorter than the minimum length of 1".to_string()));
		}
		if self.sttlm_lctn.chars().count() > 25 {
			return Err(ValidationError::new(1002, "sttlm_lctn exceeds the maximum length of 25".to_string()));
		}
		Ok(())
	}
}


// CommonFinancialInstrumentAttributes10 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CommonFinancialInstrumentAttributes10 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctySts", skip_serializing_if = "Option::is_none") )]
	pub scty_sts: Option<SecurityStatus3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISOSctyLngNm", skip_serializing_if = "Option::is_none") )]
	pub iso_scty_lng_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISOSctyShrtNm", skip_serializing_if = "Option::is_none") )]
	pub iso_scty_shrt_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NmVldFr", skip_serializing_if = "Option::is_none") )]
	pub nm_vld_fr: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DnmtnCcy") )]
	pub dnmtn_ccy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CertNb", skip_serializing_if = "Option::is_none") )]
	pub cert_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctVrsnNb", skip_serializing_if = "Option::is_none") )]
	pub ctrct_vrsn_nb: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CpnAttchdNb", skip_serializing_if = "Option::is_none") )]
	pub cpn_attchd_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxLotNb", skip_serializing_if = "Option::is_none") )]
	pub tax_lot_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PoolNb", skip_serializing_if = "Option::is_none") )]
	pub pool_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CvrdInd", skip_serializing_if = "Option::is_none") )]
	pub cvrd_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LglRstrctns", skip_serializing_if = "Option::is_none") )]
	pub lgl_rstrctns: Option<LegalRestrictions4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PosLmt", skip_serializing_if = "Option::is_none") )]
	pub pos_lmt: Option<FinancialInstrumentQuantity1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NearTermPosLmt", skip_serializing_if = "Option::is_none") )]
	pub near_term_pos_lmt: Option<FinancialInstrumentQuantity1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ListgDt", skip_serializing_if = "Option::is_none") )]
	pub listg_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RcrdDt", skip_serializing_if = "Option::is_none") )]
	pub rcrd_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XpryDt", skip_serializing_if = "Option::is_none") )]
	pub xpry_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Purp", skip_serializing_if = "Option::is_none") )]
	pub purp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClssfctnTp", skip_serializing_if = "Option::is_none") )]
	pub clssfctn_tp: Option<ClassificationType2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issnc", skip_serializing_if = "Option::is_none") )]
	pub issnc: Option<Issuance5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgMkt", skip_serializing_if = "Option::is_none") )]
	pub tradg_mkt: Option<Vec<TradingParameters2>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SprdAndBchmkCrv", skip_serializing_if = "Option::is_none") )]
	pub sprd_and_bchmk_crv: Option<Vec<BenchmarkCurve6>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PutTp", skip_serializing_if = "Option::is_none") )]
	pub put_tp: Option<PutType3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CallTp", skip_serializing_if = "Option::is_none") )]
	pub call_tp: Option<CallType3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FngbInd", skip_serializing_if = "Option::is_none") )]
	pub fngb_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cnfdtl", skip_serializing_if = "Option::is_none") )]
	pub cnfdtl: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvtPlcmnt", skip_serializing_if = "Option::is_none") )]
	pub prvt_plcmnt: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ConvtblInd", skip_serializing_if = "Option::is_none") )]
	pub convtbl_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ConvsPrd", skip_serializing_if = "Option::is_none") )]
	pub convs_prd: Option<DateTimePeriod1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ConvsRatioNmrtr", skip_serializing_if = "Option::is_none") )]
	pub convs_ratio_nmrtr: Option<FinancialInstrumentQuantity1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ConvsRatioDnmtr", skip_serializing_if = "Option::is_none") )]
	pub convs_ratio_dnmtr: Option<FinancialInstrumentQuantity1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmryPlcOfDpst", skip_serializing_if = "Option::is_none") )]
	pub pmry_plc_of_dpst: Option<PartyIdentification136>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgMtd", skip_serializing_if = "Option::is_none") )]
	pub tradg_mtd: Option<UnitOrFaceAmount1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TEFRARule", skip_serializing_if = "Option::is_none") )]
	pub tefra_rule: Option<TEFRARules3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SrNb", skip_serializing_if = "Option::is_none") )]
	pub sr_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Clss", skip_serializing_if = "Option::is_none") )]
	pub clss: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WhldgTaxRgm", skip_serializing_if = "Option::is_none") )]
	pub whldg_tax_rgm: Option<Vec<SecurityWithHoldingTax1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtSts", skip_serializing_if = "Option::is_none") )]
	pub pmt_sts: Option<SecuritiesPaymentStatus5Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitlPhysForm", skip_serializing_if = "Option::is_none") )]
	pub initl_phys_form: Option<InitialPhysicalForm4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AftrXchgPhysForm", skip_serializing_if = "Option::is_none") )]
	pub aftr_xchg_phys_form: Option<InitialPhysicalForm3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CmonSfkpr", skip_serializing_if = "Option::is_none") )]
	pub cmon_sfkpr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RedTp", skip_serializing_if = "Option::is_none") )]
	pub red_tp: Option<MaturityRedemptionType3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RedPmtCcy", skip_serializing_if = "Option::is_none") )]
	pub red_pmt_ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rstrctn", skip_serializing_if = "Option::is_none") )]
	pub rstrctn: Option<Vec<SecurityRestriction3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmInf", skip_serializing_if = "Option::is_none") )]
	pub sttlm_inf: Option<Vec<SettlementInformation17>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmForm", skip_serializing_if = "Option::is_none") )]
	pub fin_instrm_form: Option<FinancialInstrumentForm2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtctNm", skip_serializing_if = "Option::is_none") )]
	pub ctct_nm: Option<Organisation38>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LeadMgr", skip_serializing_if = "Option::is_none") )]
	pub lead_mgr: Option<Organisation38>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrncplPngAgt", skip_serializing_if = "Option::is_none") )]
	pub prncpl_png_agt: Option<Organisation38>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PngAgt", skip_serializing_if = "Option::is_none") )]
	pub png_agt: Option<Organisation38>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dpstry", skip_serializing_if = "Option::is_none") )]
	pub dpstry: Option<Organisation38>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UndrlygRsk", skip_serializing_if = "Option::is_none") )]
	pub undrlyg_rsk: Option<Organisation38>,
}

impl CommonFinancialInstrumentAttributes10 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.scty_sts { val.validate()? }
		if let Some(ref val) = self.iso_scty_lng_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "iso_scty_lng_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "iso_scty_lng_nm exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.iso_scty_shrt_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "iso_scty_shrt_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "iso_scty_shrt_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.nm_vld_fr { val.validate()? }
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.dnmtn_ccy) {
			return Err(ValidationError::new(1005, "dnmtn_ccy does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.cert_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cert_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "cert_nb exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.cpn_attchd_nb {
			let pattern = Regex::new("[0-9]{1,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "cpn_attchd_nb does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.tax_lot_nb {
			let pattern = Regex::new("[0-9]{1,15}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "tax_lot_nb does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.pool_nb {
			let pattern = Regex::new("[0-9]{1,15}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "pool_nb does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.lgl_rstrctns { val.validate()? }
		if let Some(ref val) = self.pos_lmt { val.validate()? }
		if let Some(ref val) = self.near_term_pos_lmt { val.validate()? }
		if let Some(ref val) = self.purp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "purp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 256 {
				return Err(ValidationError::new(1002, "purp exceeds the maximum length of 256".to_string()));
			}
		}
		if let Some(ref val) = self.clssfctn_tp { val.validate()? }
		if let Some(ref val) = self.issnc { val.validate()? }
		if let Some(ref vec) = self.tradg_mkt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.sprd_and_bchmk_crv { for item in vec { item.validate()? } }
		if let Some(ref val) = self.put_tp { val.validate()? }
		if let Some(ref val) = self.call_tp { val.validate()? }
		if let Some(ref val) = self.convs_prd { val.validate()? }
		if let Some(ref val) = self.convs_ratio_nmrtr { val.validate()? }
		if let Some(ref val) = self.convs_ratio_dnmtr { val.validate()? }
		if let Some(ref val) = self.pmry_plc_of_dpst { val.validate()? }
		if let Some(ref val) = self.tradg_mtd { val.validate()? }
		if let Some(ref val) = self.tefra_rule { val.validate()? }
		if let Some(ref val) = self.sr_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "sr_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 16 {
				return Err(ValidationError::new(1002, "sr_nb exceeds the maximum length of 16".to_string()));
			}
		}
		if let Some(ref val) = self.clss {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "clss is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 16 {
				return Err(ValidationError::new(1002, "clss exceeds the maximum length of 16".to_string()));
			}
		}
		if let Some(ref vec) = self.whldg_tax_rgm { for item in vec { item.validate()? } }
		if let Some(ref val) = self.pmt_sts { val.validate()? }
		if let Some(ref val) = self.initl_phys_form { val.validate()? }
		if let Some(ref val) = self.aftr_xchg_phys_form { val.validate()? }
		if let Some(ref val) = self.cmon_sfkpr {
			let pattern = Regex::new("[A-Z0-9]{4,4}[A-Z]{2,2}[A-Z0-9]{2,2}([A-Z0-9]{3,3}){0,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "cmon_sfkpr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.red_tp { val.validate()? }
		if let Some(ref val) = self.red_pmt_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "red_pmt_ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref vec) = self.rstrctn { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.sttlm_inf { for item in vec { item.validate()? } }
		if let Some(ref val) = self.fin_instrm_form { val.validate()? }
		if let Some(ref val) = self.ctct_nm { val.validate()? }
		if let Some(ref val) = self.lead_mgr { val.validate()? }
		if let Some(ref val) = self.prncpl_png_agt { val.validate()? }
		if let Some(ref val) = self.png_agt { val.validate()? }
		if let Some(ref val) = self.dpstry { val.validate()? }
		if let Some(ref val) = self.undrlyg_rsk { val.validate()? }
		Ok(())
	}
}


// CommonFinancialInstrumentAttributes11 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CommonFinancialInstrumentAttributes11 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctySts", skip_serializing_if = "Option::is_none") )]
	pub scty_sts: Option<SecurityStatus3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmNm", skip_serializing_if = "Option::is_none") )]
	pub fin_instrm_nm: Option<Vec<FinancialInstrumentName2>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DnmtnCcy", skip_serializing_if = "Option::is_none") )]
	pub dnmtn_ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CertNb", skip_serializing_if = "Option::is_none") )]
	pub cert_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctVrsnNb", skip_serializing_if = "Option::is_none") )]
	pub ctrct_vrsn_nb: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CpnAttchdNb", skip_serializing_if = "Option::is_none") )]
	pub cpn_attchd_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxLotNb", skip_serializing_if = "Option::is_none") )]
	pub tax_lot_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PoolNb", skip_serializing_if = "Option::is_none") )]
	pub pool_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CvrdInd", skip_serializing_if = "Option::is_none") )]
	pub cvrd_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LglRstrctns", skip_serializing_if = "Option::is_none") )]
	pub lgl_rstrctns: Option<LegalRestrictions4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PosLmt", skip_serializing_if = "Option::is_none") )]
	pub pos_lmt: Option<FinancialInstrumentQuantity1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NearTermPosLmt", skip_serializing_if = "Option::is_none") )]
	pub near_term_pos_lmt: Option<FinancialInstrumentQuantity1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ListgDt", skip_serializing_if = "Option::is_none") )]
	pub listg_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RcrdDt", skip_serializing_if = "Option::is_none") )]
	pub rcrd_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XpryDt", skip_serializing_if = "Option::is_none") )]
	pub xpry_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Purp", skip_serializing_if = "Option::is_none") )]
	pub purp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClssfctnTp", skip_serializing_if = "Option::is_none") )]
	pub clssfctn_tp: Option<ClassificationType2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issnc", skip_serializing_if = "Option::is_none") )]
	pub issnc: Option<Issuance6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgMkt", skip_serializing_if = "Option::is_none") )]
	pub tradg_mkt: Option<Vec<TradingParameters2>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SprdAndBchmkCrv", skip_serializing_if = "Option::is_none") )]
	pub sprd_and_bchmk_crv: Option<Vec<BenchmarkCurve6>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PutTp", skip_serializing_if = "Option::is_none") )]
	pub put_tp: Option<PutType3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CallTp", skip_serializing_if = "Option::is_none") )]
	pub call_tp: Option<CallType3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FngbInd", skip_serializing_if = "Option::is_none") )]
	pub fngb_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cnfdtl", skip_serializing_if = "Option::is_none") )]
	pub cnfdtl: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvtPlcmnt", skip_serializing_if = "Option::is_none") )]
	pub prvt_plcmnt: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ConvtblInd", skip_serializing_if = "Option::is_none") )]
	pub convtbl_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ConvsPrd", skip_serializing_if = "Option::is_none") )]
	pub convs_prd: Option<DateTimePeriod1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ConvsRatioNmrtr", skip_serializing_if = "Option::is_none") )]
	pub convs_ratio_nmrtr: Option<FinancialInstrumentQuantity1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ConvsRatioDnmtr", skip_serializing_if = "Option::is_none") )]
	pub convs_ratio_dnmtr: Option<FinancialInstrumentQuantity1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmryPlcOfDpst", skip_serializing_if = "Option::is_none") )]
	pub pmry_plc_of_dpst: Option<PartyIdentification136>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgMtd", skip_serializing_if = "Option::is_none") )]
	pub tradg_mtd: Option<UnitOrFaceAmount1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TEFRARule", skip_serializing_if = "Option::is_none") )]
	pub tefra_rule: Option<TEFRARules3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SrNb", skip_serializing_if = "Option::is_none") )]
	pub sr_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Clss", skip_serializing_if = "Option::is_none") )]
	pub clss: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WhldgTaxRgm", skip_serializing_if = "Option::is_none") )]
	pub whldg_tax_rgm: Option<Vec<SecurityWithHoldingTax1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtSts", skip_serializing_if = "Option::is_none") )]
	pub pmt_sts: Option<SecuritiesPaymentStatus5Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitlPhysForm", skip_serializing_if = "Option::is_none") )]
	pub initl_phys_form: Option<InitialPhysicalForm4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AftrXchgPhysForm", skip_serializing_if = "Option::is_none") )]
	pub aftr_xchg_phys_form: Option<InitialPhysicalForm3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CmonSfkpr", skip_serializing_if = "Option::is_none") )]
	pub cmon_sfkpr: Option<PartyIdentification177Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RedTp", skip_serializing_if = "Option::is_none") )]
	pub red_tp: Option<MaturityRedemptionType3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RedPmtCcy", skip_serializing_if = "Option::is_none") )]
	pub red_pmt_ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rstrctn", skip_serializing_if = "Option::is_none") )]
	pub rstrctn: Option<Vec<SecurityRestriction3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmIdVldty", skip_serializing_if = "Option::is_none") )]
	pub fin_instrm_id_vldty: Option<Vec<FinancialInstrumentIdentificationValidity3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmInf", skip_serializing_if = "Option::is_none") )]
	pub sttlm_inf: Option<Vec<SettlementInformation17>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmForm", skip_serializing_if = "Option::is_none") )]
	pub fin_instrm_form: Option<FinancialInstrumentForm2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtctNm", skip_serializing_if = "Option::is_none") )]
	pub ctct_nm: Option<Organisation38>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LeadMgr", skip_serializing_if = "Option::is_none") )]
	pub lead_mgr: Option<Organisation38>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrncplPngAgt", skip_serializing_if = "Option::is_none") )]
	pub prncpl_png_agt: Option<Organisation38>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PngAgt", skip_serializing_if = "Option::is_none") )]
	pub png_agt: Option<Organisation38>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dpstry", skip_serializing_if = "Option::is_none") )]
	pub dpstry: Option<Organisation38>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UndrlygRsk", skip_serializing_if = "Option::is_none") )]
	pub undrlyg_rsk: Option<Organisation38>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctyCSDLk", skip_serializing_if = "Option::is_none") )]
	pub scty_csd_lk: Option<Vec<SecurityCSDLink7>>,
}

impl CommonFinancialInstrumentAttributes11 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.scty_sts { val.validate()? }
		if let Some(ref vec) = self.fin_instrm_nm { for item in vec { item.validate()? } }
		if let Some(ref val) = self.dnmtn_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "dnmtn_ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.cert_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cert_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "cert_nb exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.cpn_attchd_nb {
			let pattern = Regex::new("[0-9]{1,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "cpn_attchd_nb does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.tax_lot_nb {
			let pattern = Regex::new("[0-9]{1,15}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "tax_lot_nb does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.pool_nb {
			let pattern = Regex::new("[0-9]{1,15}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "pool_nb does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.lgl_rstrctns { val.validate()? }
		if let Some(ref val) = self.pos_lmt { val.validate()? }
		if let Some(ref val) = self.near_term_pos_lmt { val.validate()? }
		if let Some(ref val) = self.purp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "purp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 256 {
				return Err(ValidationError::new(1002, "purp exceeds the maximum length of 256".to_string()));
			}
		}
		if let Some(ref val) = self.clssfctn_tp { val.validate()? }
		if let Some(ref val) = self.issnc { val.validate()? }
		if let Some(ref vec) = self.tradg_mkt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.sprd_and_bchmk_crv { for item in vec { item.validate()? } }
		if let Some(ref val) = self.put_tp { val.validate()? }
		if let Some(ref val) = self.call_tp { val.validate()? }
		if let Some(ref val) = self.convs_prd { val.validate()? }
		if let Some(ref val) = self.convs_ratio_nmrtr { val.validate()? }
		if let Some(ref val) = self.convs_ratio_dnmtr { val.validate()? }
		if let Some(ref val) = self.pmry_plc_of_dpst { val.validate()? }
		if let Some(ref val) = self.tradg_mtd { val.validate()? }
		if let Some(ref val) = self.tefra_rule { val.validate()? }
		if let Some(ref val) = self.sr_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "sr_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 16 {
				return Err(ValidationError::new(1002, "sr_nb exceeds the maximum length of 16".to_string()));
			}
		}
		if let Some(ref val) = self.clss {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "clss is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 16 {
				return Err(ValidationError::new(1002, "clss exceeds the maximum length of 16".to_string()));
			}
		}
		if let Some(ref vec) = self.whldg_tax_rgm { for item in vec { item.validate()? } }
		if let Some(ref val) = self.pmt_sts { val.validate()? }
		if let Some(ref val) = self.initl_phys_form { val.validate()? }
		if let Some(ref val) = self.aftr_xchg_phys_form { val.validate()? }
		if let Some(ref val) = self.cmon_sfkpr { val.validate()? }
		if let Some(ref val) = self.red_tp { val.validate()? }
		if let Some(ref val) = self.red_pmt_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "red_pmt_ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref vec) = self.rstrctn { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.fin_instrm_id_vldty { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.sttlm_inf { for item in vec { item.validate()? } }
		if let Some(ref val) = self.fin_instrm_form { val.validate()? }
		if let Some(ref val) = self.ctct_nm { val.validate()? }
		if let Some(ref val) = self.lead_mgr { val.validate()? }
		if let Some(ref val) = self.prncpl_png_agt { val.validate()? }
		if let Some(ref val) = self.png_agt { val.validate()? }
		if let Some(ref val) = self.dpstry { val.validate()? }
		if let Some(ref val) = self.undrlyg_rsk { val.validate()? }
		if let Some(ref vec) = self.scty_csd_lk { for item in vec { item.validate()? } }
		Ok(())
	}
}


// CommonFinancialInstrumentAttributes12 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CommonFinancialInstrumentAttributes12 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctySts", skip_serializing_if = "Option::is_none") )]
	pub scty_sts: Option<SecurityStatus3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISOSctyLngNm", skip_serializing_if = "Option::is_none") )]
	pub iso_scty_lng_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISOSctyShrtNm", skip_serializing_if = "Option::is_none") )]
	pub iso_scty_shrt_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NmVldFr", skip_serializing_if = "Option::is_none") )]
	pub nm_vld_fr: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DnmtnCcy", skip_serializing_if = "Option::is_none") )]
	pub dnmtn_ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CertNb", skip_serializing_if = "Option::is_none") )]
	pub cert_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctVrsnNb", skip_serializing_if = "Option::is_none") )]
	pub ctrct_vrsn_nb: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CpnAttchdNb", skip_serializing_if = "Option::is_none") )]
	pub cpn_attchd_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxLotNb", skip_serializing_if = "Option::is_none") )]
	pub tax_lot_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PoolNb", skip_serializing_if = "Option::is_none") )]
	pub pool_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CvrdInd", skip_serializing_if = "Option::is_none") )]
	pub cvrd_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LglRstrctns", skip_serializing_if = "Option::is_none") )]
	pub lgl_rstrctns: Option<LegalRestrictions4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PosLmt", skip_serializing_if = "Option::is_none") )]
	pub pos_lmt: Option<FinancialInstrumentQuantity1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NearTermPosLmt", skip_serializing_if = "Option::is_none") )]
	pub near_term_pos_lmt: Option<FinancialInstrumentQuantity1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ListgDt", skip_serializing_if = "Option::is_none") )]
	pub listg_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RcrdDt", skip_serializing_if = "Option::is_none") )]
	pub rcrd_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XpryDt", skip_serializing_if = "Option::is_none") )]
	pub xpry_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Purp", skip_serializing_if = "Option::is_none") )]
	pub purp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClssfctnTp", skip_serializing_if = "Option::is_none") )]
	pub clssfctn_tp: Option<ClassificationType2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issnc", skip_serializing_if = "Option::is_none") )]
	pub issnc: Option<Issuance5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgMkt", skip_serializing_if = "Option::is_none") )]
	pub tradg_mkt: Option<Vec<TradingParameters2>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SprdAndBchmkCrv", skip_serializing_if = "Option::is_none") )]
	pub sprd_and_bchmk_crv: Option<Vec<BenchmarkCurve6>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PutTp", skip_serializing_if = "Option::is_none") )]
	pub put_tp: Option<PutType3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CallTp", skip_serializing_if = "Option::is_none") )]
	pub call_tp: Option<CallType3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FngbInd", skip_serializing_if = "Option::is_none") )]
	pub fngb_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cnfdtl", skip_serializing_if = "Option::is_none") )]
	pub cnfdtl: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvtPlcmnt", skip_serializing_if = "Option::is_none") )]
	pub prvt_plcmnt: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ConvtblInd", skip_serializing_if = "Option::is_none") )]
	pub convtbl_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ConvsPrd", skip_serializing_if = "Option::is_none") )]
	pub convs_prd: Option<DateTimePeriod1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ConvsRatioNmrtr", skip_serializing_if = "Option::is_none") )]
	pub convs_ratio_nmrtr: Option<FinancialInstrumentQuantity1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ConvsRatioDnmtr", skip_serializing_if = "Option::is_none") )]
	pub convs_ratio_dnmtr: Option<FinancialInstrumentQuantity1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmryPlcOfDpst", skip_serializing_if = "Option::is_none") )]
	pub pmry_plc_of_dpst: Option<PartyIdentification136>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgMtd", skip_serializing_if = "Option::is_none") )]
	pub tradg_mtd: Option<UnitOrFaceAmount1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TEFRARule", skip_serializing_if = "Option::is_none") )]
	pub tefra_rule: Option<TEFRARules3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SrNb", skip_serializing_if = "Option::is_none") )]
	pub sr_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Clss", skip_serializing_if = "Option::is_none") )]
	pub clss: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WhldgTaxRgm", skip_serializing_if = "Option::is_none") )]
	pub whldg_tax_rgm: Option<Vec<SecurityWithHoldingTax1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtSts", skip_serializing_if = "Option::is_none") )]
	pub pmt_sts: Option<SecuritiesPaymentStatus5Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitlPhysForm", skip_serializing_if = "Option::is_none") )]
	pub initl_phys_form: Option<InitialPhysicalForm4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AftrXchgPhysForm", skip_serializing_if = "Option::is_none") )]
	pub aftr_xchg_phys_form: Option<InitialPhysicalForm3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CmonSfkpr", skip_serializing_if = "Option::is_none") )]
	pub cmon_sfkpr: Option<PartyIdentification177Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RedTp", skip_serializing_if = "Option::is_none") )]
	pub red_tp: Option<MaturityRedemptionType3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RedPmtCcy", skip_serializing_if = "Option::is_none") )]
	pub red_pmt_ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rstrctn", skip_serializing_if = "Option::is_none") )]
	pub rstrctn: Option<Vec<SecurityRestriction3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmId", skip_serializing_if = "Option::is_none") )]
	pub fin_instrm_id: Option<SecurityIdentification39>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmInf", skip_serializing_if = "Option::is_none") )]
	pub sttlm_inf: Option<Vec<SettlementInformation17>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmForm", skip_serializing_if = "Option::is_none") )]
	pub fin_instrm_form: Option<FinancialInstrumentForm2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtctNm", skip_serializing_if = "Option::is_none") )]
	pub ctct_nm: Option<Organisation38>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LeadMgr", skip_serializing_if = "Option::is_none") )]
	pub lead_mgr: Option<Organisation38>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrncplPngAgt", skip_serializing_if = "Option::is_none") )]
	pub prncpl_png_agt: Option<Organisation38>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PngAgt", skip_serializing_if = "Option::is_none") )]
	pub png_agt: Option<Organisation38>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dpstry", skip_serializing_if = "Option::is_none") )]
	pub dpstry: Option<Organisation38>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UndrlygRsk", skip_serializing_if = "Option::is_none") )]
	pub undrlyg_rsk: Option<Organisation38>,
}

impl CommonFinancialInstrumentAttributes12 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.scty_sts { val.validate()? }
		if let Some(ref val) = self.iso_scty_lng_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "iso_scty_lng_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "iso_scty_lng_nm exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.iso_scty_shrt_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "iso_scty_shrt_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "iso_scty_shrt_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.nm_vld_fr { val.validate()? }
		if let Some(ref val) = self.dnmtn_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "dnmtn_ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.cert_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cert_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "cert_nb exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.cpn_attchd_nb {
			let pattern = Regex::new("[0-9]{1,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "cpn_attchd_nb does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.tax_lot_nb {
			let pattern = Regex::new("[0-9]{1,15}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "tax_lot_nb does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.pool_nb {
			let pattern = Regex::new("[0-9]{1,15}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "pool_nb does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.lgl_rstrctns { val.validate()? }
		if let Some(ref val) = self.pos_lmt { val.validate()? }
		if let Some(ref val) = self.near_term_pos_lmt { val.validate()? }
		if let Some(ref val) = self.purp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "purp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 256 {
				return Err(ValidationError::new(1002, "purp exceeds the maximum length of 256".to_string()));
			}
		}
		if let Some(ref val) = self.clssfctn_tp { val.validate()? }
		if let Some(ref val) = self.issnc { val.validate()? }
		if let Some(ref vec) = self.tradg_mkt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.sprd_and_bchmk_crv { for item in vec { item.validate()? } }
		if let Some(ref val) = self.put_tp { val.validate()? }
		if let Some(ref val) = self.call_tp { val.validate()? }
		if let Some(ref val) = self.convs_prd { val.validate()? }
		if let Some(ref val) = self.convs_ratio_nmrtr { val.validate()? }
		if let Some(ref val) = self.convs_ratio_dnmtr { val.validate()? }
		if let Some(ref val) = self.pmry_plc_of_dpst { val.validate()? }
		if let Some(ref val) = self.tradg_mtd { val.validate()? }
		if let Some(ref val) = self.tefra_rule { val.validate()? }
		if let Some(ref val) = self.sr_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "sr_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 16 {
				return Err(ValidationError::new(1002, "sr_nb exceeds the maximum length of 16".to_string()));
			}
		}
		if let Some(ref val) = self.clss {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "clss is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 16 {
				return Err(ValidationError::new(1002, "clss exceeds the maximum length of 16".to_string()));
			}
		}
		if let Some(ref vec) = self.whldg_tax_rgm { for item in vec { item.validate()? } }
		if let Some(ref val) = self.pmt_sts { val.validate()? }
		if let Some(ref val) = self.initl_phys_form { val.validate()? }
		if let Some(ref val) = self.aftr_xchg_phys_form { val.validate()? }
		if let Some(ref val) = self.cmon_sfkpr { val.validate()? }
		if let Some(ref val) = self.red_tp { val.validate()? }
		if let Some(ref val) = self.red_pmt_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "red_pmt_ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref vec) = self.rstrctn { for item in vec { item.validate()? } }
		if let Some(ref val) = self.fin_instrm_id { val.validate()? }
		if let Some(ref vec) = self.sttlm_inf { for item in vec { item.validate()? } }
		if let Some(ref val) = self.fin_instrm_form { val.validate()? }
		if let Some(ref val) = self.ctct_nm { val.validate()? }
		if let Some(ref val) = self.lead_mgr { val.validate()? }
		if let Some(ref val) = self.prncpl_png_agt { val.validate()? }
		if let Some(ref val) = self.png_agt { val.validate()? }
		if let Some(ref val) = self.dpstry { val.validate()? }
		if let Some(ref val) = self.undrlyg_rsk { val.validate()? }
		Ok(())
	}
}


// CommonTradeDataReport71 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CommonTradeDataReport71 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctData", skip_serializing_if = "Option::is_none") )]
	pub ctrct_data: Option<ContractType15>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxData") )]
	pub tx_data: TradeTransaction50,
}

impl CommonTradeDataReport71 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ctrct_data { val.validate()? }
		self.tx_data.validate()?;
		Ok(())
	}
}


// CommonTradeDataReport72 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CommonTradeDataReport72 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctData", skip_serializing_if = "Option::is_none") )]
	pub ctrct_data: Option<ContractType15>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxData") )]
	pub tx_data: TradeTransaction50,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctMod", skip_serializing_if = "Option::is_none") )]
	pub ctrct_mod: Option<ContractModification9>,
}

impl CommonTradeDataReport72 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ctrct_data { val.validate()? }
		self.tx_data.validate()?;
		if let Some(ref val) = self.ctrct_mod { val.validate()? }
		Ok(())
	}
}


// CommunicationAddress10 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CommunicationAddress10 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstlAdr") )]
	pub pstl_adr: LongPostalAddress1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PhneNb") )]
	pub phne_nb: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FaxNb", skip_serializing_if = "Option::is_none") )]
	pub fax_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EmailAdr", skip_serializing_if = "Option::is_none") )]
	pub email_adr: Option<String>,
}

impl CommunicationAddress10 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pstl_adr.validate()?;
		let pattern = Regex::new("\\+[0-9]{1,3}-[0-9()+\\-]{1,30}").unwrap();
		if !pattern.is_match(&self.phne_nb) {
			return Err(ValidationError::new(1005, "phne_nb does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.fax_nb {
			let pattern = Regex::new("\\+[0-9]{1,3}-[0-9()+\\-]{1,30}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "fax_nb does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.email_adr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "email_adr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 2048 {
				return Err(ValidationError::new(1002, "email_adr exceeds the maximum length of 2048".to_string()));
			}
		}
		Ok(())
	}
}


// CommunicationAddress3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CommunicationAddress3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Email", skip_serializing_if = "Option::is_none") )]
	pub email: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Phne", skip_serializing_if = "Option::is_none") )]
	pub phne: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mob", skip_serializing_if = "Option::is_none") )]
	pub mob: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FaxNb", skip_serializing_if = "Option::is_none") )]
	pub fax_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TlxAdr", skip_serializing_if = "Option::is_none") )]
	pub tlx_adr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "URLAdr", skip_serializing_if = "Option::is_none") )]
	pub url_adr: Option<String>,
}

impl CommunicationAddress3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.email {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "email is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 256 {
				return Err(ValidationError::new(1002, "email exceeds the maximum length of 256".to_string()));
			}
		}
		if let Some(ref val) = self.phne {
			let pattern = Regex::new("\\+[0-9]{1,3}-[0-9()+\\-]{1,30}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "phne does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.mob {
			let pattern = Regex::new("\\+[0-9]{1,3}-[0-9()+\\-]{1,30}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "mob does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.fax_nb {
			let pattern = Regex::new("\\+[0-9]{1,3}-[0-9()+\\-]{1,30}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "fax_nb does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.tlx_adr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tlx_adr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tlx_adr exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.url_adr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "url_adr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 256 {
				return Err(ValidationError::new(1002, "url_adr exceeds the maximum length of 256".to_string()));
			}
		}
		Ok(())
	}
}


// CommunicationAddress6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CommunicationAddress6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AdrTp", skip_serializing_if = "Option::is_none") )]
	pub adr_tp: Option<AddressType1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Email", skip_serializing_if = "Option::is_none") )]
	pub email: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Phne", skip_serializing_if = "Option::is_none") )]
	pub phne: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mob", skip_serializing_if = "Option::is_none") )]
	pub mob: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FaxNb", skip_serializing_if = "Option::is_none") )]
	pub fax_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TlxAdr", skip_serializing_if = "Option::is_none") )]
	pub tlx_adr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "URLAdr", skip_serializing_if = "Option::is_none") )]
	pub url_adr: Option<String>,
}

impl CommunicationAddress6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.adr_tp { val.validate()? }
		if let Some(ref val) = self.email {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "email is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 256 {
				return Err(ValidationError::new(1002, "email exceeds the maximum length of 256".to_string()));
			}
		}
		if let Some(ref val) = self.phne {
			let pattern = Regex::new("\\+[0-9]{1,3}-[0-9()+\\-]{1,30}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "phne does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.mob {
			let pattern = Regex::new("\\+[0-9]{1,3}-[0-9()+\\-]{1,30}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "mob does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.fax_nb {
			let pattern = Regex::new("\\+[0-9]{1,3}-[0-9()+\\-]{1,30}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "fax_nb does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.tlx_adr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tlx_adr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tlx_adr exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.url_adr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "url_adr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 256 {
				return Err(ValidationError::new(1002, "url_adr exceeds the maximum length of 256".to_string()));
			}
		}
		Ok(())
	}
}


// CommunicationAddress7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CommunicationAddress7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Email", skip_serializing_if = "Option::is_none") )]
	pub email: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PhneNb", skip_serializing_if = "Option::is_none") )]
	pub phne_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MobNb", skip_serializing_if = "Option::is_none") )]
	pub mob_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FaxNb", skip_serializing_if = "Option::is_none") )]
	pub fax_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TlxAdr", skip_serializing_if = "Option::is_none") )]
	pub tlx_adr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "URLAdr", skip_serializing_if = "Option::is_none") )]
	pub url_adr: Option<String>,
}

impl CommunicationAddress7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.email {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "email is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 2048 {
				return Err(ValidationError::new(1002, "email exceeds the maximum length of 2048".to_string()));
			}
		}
		if let Some(ref val) = self.phne_nb {
			let pattern = Regex::new("\\+[0-9]{1,3}-[0-9()+\\-]{1,30}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "phne_nb does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.mob_nb {
			let pattern = Regex::new("\\+[0-9]{1,3}-[0-9()+\\-]{1,30}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "mob_nb does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.fax_nb {
			let pattern = Regex::new("\\+[0-9]{1,3}-[0-9()+\\-]{1,30}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "fax_nb does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.tlx_adr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tlx_adr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tlx_adr exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.url_adr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "url_adr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 2048 {
				return Err(ValidationError::new(1002, "url_adr exceeds the maximum length of 2048".to_string()));
			}
		}
		Ok(())
	}
}


// CommunicationAddress8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CommunicationAddress8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstlAdr") )]
	pub pstl_adr: LongPostalAddress1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PhneNb") )]
	pub phne_nb: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FaxNb", skip_serializing_if = "Option::is_none") )]
	pub fax_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EmailAdr", skip_serializing_if = "Option::is_none") )]
	pub email_adr: Option<String>,
}

impl CommunicationAddress8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pstl_adr.validate()?;
		let pattern = Regex::new("\\+[0-9]{1,3}-[0-9()+\\-]{1,30}").unwrap();
		if !pattern.is_match(&self.phne_nb) {
			return Err(ValidationError::new(1005, "phne_nb does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.fax_nb {
			let pattern = Regex::new("\\+[0-9]{1,3}-[0-9()+\\-]{1,30}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "fax_nb does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.email_adr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "email_adr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 256 {
				return Err(ValidationError::new(1002, "email_adr exceeds the maximum length of 256".to_string()));
			}
		}
		Ok(())
	}
}


// CommunicationFormat1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CommunicationFormat1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl CommunicationFormat1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// CommunicationMethod1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CommunicationMethod1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "SWMT") )]
	CodeSWMT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SWMX") )]
	CodeSWMX,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FAXI") )]
	CodeFAXI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EMAL") )]
	CodeEMAL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PROP") )]
	CodePROP,
}

impl CommunicationMethod1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CommunicationMethod2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CommunicationMethod2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<CommunicationMethod2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl CommunicationMethod2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// CommunicationMethod2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CommunicationMethod2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "EMAL") )]
	CodeEMAL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FAXI") )]
	CodeFAXI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FILE") )]
	CodeFILE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ONLI") )]
	CodeONLI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "POST") )]
	CodePOST,
}

impl CommunicationMethod2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CommunicationMethod3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CommunicationMethod3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<CommunicationMethod1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl CommunicationMethod3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// CommunicationMethod3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CommunicationMethod3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "EMAL") )]
	CodeEMAL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FAXI") )]
	CodeFAXI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "POST") )]
	CodePOST,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PHON") )]
	CodePHON,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FILE") )]
	CodeFILE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ONLI") )]
	CodeONLI,
}

impl CommunicationMethod3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CommunicationMethod4Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CommunicationMethod4Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "EMAL") )]
	CodeEMAL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FAXI") )]
	CodeFAXI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FILE") )]
	CodeFILE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ONLI") )]
	CodeONLI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PHON") )]
	CodePHON,
	#[cfg_attr( feature = "derive_serde", serde(rename = "POST") )]
	CodePOST,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PROP") )]
	CodePROP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SWMT") )]
	CodeSWMT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SWMX") )]
	CodeSWMX,
}

impl CommunicationMethod4Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CompanyLink1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompanyLink1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<CompanyLink1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl CompanyLink1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// CompanyLink1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CompanyLink1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "AGEN") )]
	CodeAGEN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BROK") )]
	CodeBROK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PART") )]
	CodePART,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MEMB") )]
	CodeMEMB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PCOM") )]
	CodePCOM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RELA") )]
	CodeRELA,
}

impl CompanyLink1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CompareActiveOrHistoricCurrencyAndAmount3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareActiveOrHistoricCurrencyAndAmount3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<ActiveOrHistoricCurrencyAndAmount>,
}

impl CompareActiveOrHistoricCurrencyAndAmount3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareActiveOrHistoricCurrencyAndAmount4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareActiveOrHistoricCurrencyAndAmount4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<ActiveOrHistoricCurrencyAnd19DecimalAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<ActiveOrHistoricCurrencyAnd19DecimalAmount>,
}

impl CompareActiveOrHistoricCurrencyAndAmount4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareActiveOrHistoricCurrencyCode1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareActiveOrHistoricCurrencyCode1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<String>,
}

impl CompareActiveOrHistoricCurrencyCode1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "val1 does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.val2 {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "val2 does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// CompareAgreementType2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareAgreementType2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<AgreementType1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<AgreementType1Choice>,
}

impl CompareAgreementType2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareAmountAndDirection1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareAmountAndDirection1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<AmountAndDirection53>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<AmountAndDirection53>,
}

impl CompareAmountAndDirection1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareAmountAndDirection2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareAmountAndDirection2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<AmountAndDirection53>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<AmountAndDirection53>,
}

impl CompareAmountAndDirection2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareAmountAndDirection3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareAmountAndDirection3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<AmountAndDirection106>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<AmountAndDirection106>,
}

impl CompareAmountAndDirection3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareAssetClass1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareAssetClass1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<ProductType4Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<ProductType4Code>,
}

impl CompareAssetClass1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareBenchmarkCode1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareBenchmarkCode1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<String>,
}

impl CompareBenchmarkCode1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "val1 is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "val1 exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.val2 {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "val2 is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "val2 exceeds the maximum length of 4".to_string()));
			}
		}
		Ok(())
	}
}


// CompareBenchmarkCurveName3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareBenchmarkCurveName3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<BenchmarkCurveName10Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<BenchmarkCurveName10Choice>,
}

impl CompareBenchmarkCurveName3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareCFIIdentifier3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareCFIIdentifier3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<String>,
}

impl CompareCFIIdentifier3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 {
			let pattern = Regex::new("[A-Z]{6,6}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "val1 does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.val2 {
			let pattern = Regex::new("[A-Z]{6,6}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "val2 does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// CompareClearingStatus3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareClearingStatus3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<Cleared4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<Cleared4Choice>,
}

impl CompareClearingStatus3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareCollateralQualityType3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareCollateralQualityType3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<CollateralQualityType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<CollateralQualityType1Code>,
}

impl CompareCollateralQualityType3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareCommodityAssetClass3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareCommodityAssetClass3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<AssetClassCommodity5Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<AssetClassCommodity5Choice>,
}

impl CompareCommodityAssetClass3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareCommodityAssetClass4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareCommodityAssetClass4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<AssetClassCommodity6Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<AssetClassCommodity6Choice>,
}

impl CompareCommodityAssetClass4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareCounterpartySide2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareCounterpartySide2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<CollateralRole1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<CollateralRole1Code>,
}

impl CompareCounterpartySide2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareCountryCode3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareCountryCode3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<String>,
}

impl CompareCountryCode3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "val1 does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.val2 {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "val2 does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// CompareDate3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareDate3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<String>,
}

impl CompareDate3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CompareDatePeriod2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareDatePeriod2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<DatePeriod4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<DatePeriod4>,
}

impl CompareDatePeriod2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareDateTime3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareDateTime3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<String>,
}

impl CompareDateTime3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CompareDayCount1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareDayCount1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<InterestComputationMethodFormat7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<InterestComputationMethodFormat7>,
}

impl CompareDayCount1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareDecimalNumber3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareDecimalNumber3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<f64>,
}

impl CompareDecimalNumber3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CompareDeliveryInterconnectionPoint1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareDeliveryInterconnectionPoint1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<DeliveryInterconnectionPoint1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<DeliveryInterconnectionPoint1Choice>,
}

impl CompareDeliveryInterconnectionPoint1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareDeliveryMethod3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareDeliveryMethod3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<CollateralDeliveryMethod1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<CollateralDeliveryMethod1Code>,
}

impl CompareDeliveryMethod3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareDeliveryType1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareDeliveryType1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<PhysicalTransferType4Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<PhysicalTransferType4Code>,
}

impl CompareDeliveryType1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareDerivativeEvent1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareDerivativeEvent1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<DerivativeEvent6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<DerivativeEvent6>,
}

impl CompareDerivativeEvent1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareDurationType1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareDurationType1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<DurationType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<DurationType1Code>,
}

impl CompareDurationType1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareEnergyDeliveryAttribute1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareEnergyDeliveryAttribute1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NrgyDlvryIntrvl", skip_serializing_if = "Option::is_none") )]
	pub nrgy_dlvry_intrvl: Option<Vec<CompareTimePeriod2>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NrgyDt", skip_serializing_if = "Option::is_none") )]
	pub nrgy_dt: Option<CompareDatePeriod2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NrgyDrtn", skip_serializing_if = "Option::is_none") )]
	pub nrgy_drtn: Option<CompareDurationType1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NrgyWkDay", skip_serializing_if = "Option::is_none") )]
	pub nrgy_wk_day: Option<Vec<CompareWeekDay1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NrgyDlvryCpcty", skip_serializing_if = "Option::is_none") )]
	pub nrgy_dlvry_cpcty: Option<CompareLongFraction19DecimalNumber1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NrgyQtyUnit", skip_serializing_if = "Option::is_none") )]
	pub nrgy_qty_unit: Option<CompareEnergyQuantityUnit1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NrgyPricTmIntrvlQty", skip_serializing_if = "Option::is_none") )]
	pub nrgy_pric_tm_intrvl_qty: Option<CompareAmountAndDirection3>,
}

impl CompareEnergyDeliveryAttribute1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.nrgy_dlvry_intrvl { for item in vec { item.validate()? } }
		if let Some(ref val) = self.nrgy_dt { val.validate()? }
		if let Some(ref val) = self.nrgy_drtn { val.validate()? }
		if let Some(ref vec) = self.nrgy_wk_day { for item in vec { item.validate()? } }
		if let Some(ref val) = self.nrgy_dlvry_cpcty { val.validate()? }
		if let Some(ref val) = self.nrgy_qty_unit { val.validate()? }
		if let Some(ref val) = self.nrgy_pric_tm_intrvl_qty { val.validate()? }
		Ok(())
	}
}


// CompareEnergyLoadType1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareEnergyLoadType1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<EnergyLoadType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<EnergyLoadType1Code>,
}

impl CompareEnergyLoadType1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareEnergyQuantityUnit1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareEnergyQuantityUnit1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<EnergyQuantityUnit2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<EnergyQuantityUnit2Choice>,
}

impl CompareEnergyQuantityUnit1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareExchangeRate1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareExchangeRate1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<f64>,
}

impl CompareExchangeRate1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CompareExchangeRateBasis1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareExchangeRateBasis1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<ExchangeRateBasis1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<ExchangeRateBasis1Choice>,
}

impl CompareExchangeRateBasis1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareExposureType3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareExposureType3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<ExposureType10Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<ExposureType10Code>,
}

impl CompareExposureType3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareFinancialInstrumentContractType1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareFinancialInstrumentContractType1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<FinancialInstrumentContractType2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<FinancialInstrumentContractType2Code>,
}

impl CompareFinancialInstrumentContractType1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareFrequencyUnit1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareFrequencyUnit1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<Frequency13Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<Frequency13Code>,
}

impl CompareFrequencyUnit1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareISINIdentifier2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareISINIdentifier2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<String>,
}

impl CompareISINIdentifier2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 {
			let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "val1 does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.val2 {
			let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "val2 does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// CompareISINIdentifier4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareISINIdentifier4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<String>,
}

impl CompareISINIdentifier4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 {
			let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "val1 does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.val2 {
			let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "val2 does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// CompareInterestComputationMethod3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareInterestComputationMethod3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<InterestComputationMethodFormat6Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<InterestComputationMethodFormat6Choice>,
}

impl CompareInterestComputationMethod3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareInterestRate1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareInterestRate1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MrgnLnAmt", skip_serializing_if = "Option::is_none") )]
	pub mrgn_ln_amt: Option<CompareAmountAndDirection1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FxdIntrstRate", skip_serializing_if = "Option::is_none") )]
	pub fxd_intrst_rate: Option<ComparePercentageRate3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DayCntBsis", skip_serializing_if = "Option::is_none") )]
	pub day_cnt_bsis: Option<CompareInterestComputationMethod3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FltgIntrstRefRate", skip_serializing_if = "Option::is_none") )]
	pub fltg_intrst_ref_rate: Option<CompareBenchmarkCurveName3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FltgIntrstRateTermUnit", skip_serializing_if = "Option::is_none") )]
	pub fltg_intrst_rate_term_unit: Option<CompareRateBasis3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FltgIntrstRateTermVal", skip_serializing_if = "Option::is_none") )]
	pub fltg_intrst_rate_term_val: Option<CompareNumber5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FltgIntrstRatePmtFrqcyUnit", skip_serializing_if = "Option::is_none") )]
	pub fltg_intrst_rate_pmt_frqcy_unit: Option<CompareRateBasis3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FltgIntrstRatePmtFrqcyVal", skip_serializing_if = "Option::is_none") )]
	pub fltg_intrst_rate_pmt_frqcy_val: Option<CompareNumber5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FltgIntrstRateRstFrqcyUnit", skip_serializing_if = "Option::is_none") )]
	pub fltg_intrst_rate_rst_frqcy_unit: Option<CompareRateBasis3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FltgIntrstRateRstFrqcyVal", skip_serializing_if = "Option::is_none") )]
	pub fltg_intrst_rate_rst_frqcy_val: Option<CompareNumber6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BsisPtSprd", skip_serializing_if = "Option::is_none") )]
	pub bsis_pt_sprd: Option<CompareDecimalNumber3>,
}

impl CompareInterestRate1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mrgn_ln_amt { val.validate()? }
		if let Some(ref val) = self.fxd_intrst_rate { val.validate()? }
		if let Some(ref val) = self.day_cnt_bsis { val.validate()? }
		if let Some(ref val) = self.fltg_intrst_ref_rate { val.validate()? }
		if let Some(ref val) = self.fltg_intrst_rate_term_unit { val.validate()? }
		if let Some(ref val) = self.fltg_intrst_rate_term_val { val.validate()? }
		if let Some(ref val) = self.fltg_intrst_rate_pmt_frqcy_unit { val.validate()? }
		if let Some(ref val) = self.fltg_intrst_rate_pmt_frqcy_val { val.validate()? }
		if let Some(ref val) = self.fltg_intrst_rate_rst_frqcy_unit { val.validate()? }
		if let Some(ref val) = self.fltg_intrst_rate_rst_frqcy_val { val.validate()? }
		if let Some(ref val) = self.bsis_pt_sprd { val.validate()? }
		Ok(())
	}
}


// CompareLegDirection2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareLegDirection2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<Direction4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<Direction4Choice>,
}

impl CompareLegDirection2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareLongFraction19DecimalNumber1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareLongFraction19DecimalNumber1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<f64>,
}

impl CompareLongFraction19DecimalNumber1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CompareMICIdentifier3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareMICIdentifier3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<String>,
}

impl CompareMICIdentifier3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 {
			let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "val1 does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.val2 {
			let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "val2 does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// CompareMasterAgreementType1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareMasterAgreementType1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<AgreementType2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<AgreementType2Choice>,
}

impl CompareMasterAgreementType1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareMax350Text1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareMax350Text1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<String>,
}

impl CompareMax350Text1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "val1 is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "val1 exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.val2 {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "val2 is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "val2 exceeds the maximum length of 350".to_string()));
			}
		}
		Ok(())
	}
}


// CompareMax50Text1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareMax50Text1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<String>,
}

impl CompareMax50Text1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "val1 is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 50 {
				return Err(ValidationError::new(1002, "val1 exceeds the maximum length of 50".to_string()));
			}
		}
		if let Some(ref val) = self.val2 {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "val2 is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 50 {
				return Err(ValidationError::new(1002, "val2 exceeds the maximum length of 50".to_string()));
			}
		}
		Ok(())
	}
}


// CompareNumber5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareNumber5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<f64>,
}

impl CompareNumber5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CompareNumber6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareNumber6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<f64>,
}

impl CompareNumber6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CompareNumber7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareNumber7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<f64>,
}

impl CompareNumber7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CompareOptionStyle1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareOptionStyle1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<OptionStyle6Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<OptionStyle6Code>,
}

impl CompareOptionStyle1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareOptionType1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareOptionType1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<OptionType2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<OptionType2Code>,
}

impl CompareOptionType1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareOrganisationIdentification6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareOrganisationIdentification6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<OrganisationIdentification15Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<OrganisationIdentification15Choice>,
}

impl CompareOrganisationIdentification6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareOrganisationIdentification7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareOrganisationIdentification7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<PartyIdentification236Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<PartyIdentification236Choice>,
}

impl CompareOrganisationIdentification7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareOtherPayment1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareOtherPayment1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrPmtTp", skip_serializing_if = "Option::is_none") )]
	pub othr_pmt_tp: Option<CompareOtherPaymentType1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrPmtAmt", skip_serializing_if = "Option::is_none") )]
	pub othr_pmt_amt: Option<CompareAmountAndDirection3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrPmtDt", skip_serializing_if = "Option::is_none") )]
	pub othr_pmt_dt: Option<CompareDate3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrPmtPyer", skip_serializing_if = "Option::is_none") )]
	pub othr_pmt_pyer: Option<CompareOrganisationIdentification7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrPmtRcvr", skip_serializing_if = "Option::is_none") )]
	pub othr_pmt_rcvr: Option<CompareOrganisationIdentification7>,
}

impl CompareOtherPayment1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.othr_pmt_tp { val.validate()? }
		if let Some(ref val) = self.othr_pmt_amt { val.validate()? }
		if let Some(ref val) = self.othr_pmt_dt { val.validate()? }
		if let Some(ref val) = self.othr_pmt_pyer { val.validate()? }
		if let Some(ref val) = self.othr_pmt_rcvr { val.validate()? }
		Ok(())
	}
}


// CompareOtherPaymentType1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareOtherPaymentType1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<PaymentType5Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<PaymentType5Choice>,
}

impl CompareOtherPaymentType1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// ComparePercentageRate3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ComparePercentageRate3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<f64>,
}

impl ComparePercentageRate3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ComparePostTradeRiskReduction2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ComparePostTradeRiskReduction2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<PTRREvent3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<PTRREvent3>,
}

impl ComparePostTradeRiskReduction2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareRateBasis3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareRateBasis3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<RateBasis1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<RateBasis1Code>,
}

impl CompareRateBasis3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareReferenceParty1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareReferenceParty1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<DerivativePartyIdentification1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<DerivativePartyIdentification1Choice>,
}

impl CompareReferenceParty1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareReportingLevelType2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareReportingLevelType2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<ModificationLevel1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<ModificationLevel1Code>,
}

impl CompareReportingLevelType2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareReportingLevelType3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareReportingLevelType3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<ModificationLevel1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<ModificationLevel1Code>,
}

impl CompareReportingLevelType3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareSecuritiesLendingType3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareSecuritiesLendingType3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<SecuritiesLendingType3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<SecuritiesLendingType3Choice>,
}

impl CompareSecuritiesLendingType3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareSecurityIdentification4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareSecurityIdentification4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<SecurityIdentification26Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<SecurityIdentification26Choice>,
}

impl CompareSecurityIdentification4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareSeniorityType1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareSeniorityType1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<DebtInstrumentSeniorityType2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<DebtInstrumentSeniorityType2Code>,
}

impl CompareSeniorityType1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareSpecialCollateral3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareSpecialCollateral3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<SpecialCollateral1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<SpecialCollateral1Code>,
}

impl CompareSpecialCollateral3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareTerminationOption3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareTerminationOption3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<RepoTerminationOption2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<RepoTerminationOption2Code>,
}

impl CompareTerminationOption3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareText1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareText1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<String>,
}

impl CompareText1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "val1 is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 52 {
				return Err(ValidationError::new(1002, "val1 exceeds the maximum length of 52".to_string()));
			}
		}
		if let Some(ref val) = self.val2 {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "val2 is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 52 {
				return Err(ValidationError::new(1002, "val2 exceeds the maximum length of 52".to_string()));
			}
		}
		Ok(())
	}
}


// CompareText2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareText2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<String>,
}

impl CompareText2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "val1 is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 52 {
				return Err(ValidationError::new(1002, "val1 exceeds the maximum length of 52".to_string()));
			}
		}
		if let Some(ref val) = self.val2 {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "val2 is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 52 {
				return Err(ValidationError::new(1002, "val2 exceeds the maximum length of 52".to_string()));
			}
		}
		Ok(())
	}
}


// CompareTimePeriod2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareTimePeriod2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<TimePeriod3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<TimePeriod3>,
}

impl CompareTimePeriod2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareTradeClearingObligation1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareTradeClearingObligation1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<ClearingObligationType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<ClearingObligationType1Code>,
}

impl CompareTradeClearingObligation1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareTradeClearingStatus3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareTradeClearingStatus3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<Cleared23Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<Cleared23Choice>,
}

impl CompareTradeClearingStatus3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareTradeConfirmation2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareTradeConfirmation2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<TradeConfirmation3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<TradeConfirmation3Choice>,
}

impl CompareTradeConfirmation2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareTrancheIndicator1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareTrancheIndicator1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<TrancheIndicator3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<TrancheIndicator3Choice>,
}

impl CompareTrancheIndicator1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareTrueFalseIndicator3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareTrueFalseIndicator3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<bool>,
}

impl CompareTrueFalseIndicator3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CompareUnderlyingInstrument3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareUnderlyingInstrument3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<SecurityIdentification41Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<SecurityIdentification41Choice>,
}

impl CompareUnderlyingInstrument3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareUniqueProductIdentifier2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareUniqueProductIdentifier2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<UniqueProductIdentifier2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<UniqueProductIdentifier2Choice>,
}

impl CompareUniqueProductIdentifier2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareUniqueTransactionIdentifier2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareUniqueTransactionIdentifier2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<UniqueTransactionIdentifier2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<UniqueTransactionIdentifier2Choice>,
}

impl CompareUniqueTransactionIdentifier2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareUnitOfMeasure3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareUnitOfMeasure3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<UnitOfMeasure11Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<UnitOfMeasure11Code>,
}

impl CompareUnitOfMeasure3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareUnitPrice4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareUnitPrice4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<SecuritiesTransactionPrice17Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<SecuritiesTransactionPrice17Choice>,
}

impl CompareUnitPrice4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareUnitPrice5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareUnitPrice5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<SecuritiesTransactionPrice17Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<SecuritiesTransactionPrice17Choice>,
}

impl CompareUnitPrice5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareUnitPrice6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareUnitPrice6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<SecuritiesTransactionPrice19Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<SecuritiesTransactionPrice19Choice>,
}

impl CompareUnitPrice6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareUnitPrice7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareUnitPrice7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<SecuritiesTransactionPrice14Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<SecuritiesTransactionPrice14Choice>,
}

impl CompareUnitPrice7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareUnitPrice8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareUnitPrice8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<SecuritiesTransactionPrice13Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<SecuritiesTransactionPrice13Choice>,
}

impl CompareUnitPrice8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareValuationType1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareValuationType1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<ValuationType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<ValuationType1Code>,
}

impl CompareValuationType1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// CompareWeekDay1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompareWeekDay1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val1", skip_serializing_if = "Option::is_none") )]
	pub val1: Option<WeekDay3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val2", skip_serializing_if = "Option::is_none") )]
	pub val2: Option<WeekDay3Code>,
}

impl CompareWeekDay1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val1 { val.validate()? }
		if let Some(ref val) = self.val2 { val.validate()? }
		Ok(())
	}
}


// Compensation5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Compensation5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgt") )]
	pub dbtr_agt: BranchAndFinancialInstitutionIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgt") )]
	pub cdtr_agt: BranchAndFinancialInstitutionIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub cdtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn") )]
	pub rsn: CompensationReason1Choice,
}

impl Compensation5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.amt.validate()?;
		self.dbtr_agt.validate()?;
		if let Some(ref val) = self.dbtr_agt_acct { val.validate()? }
		self.cdtr_agt.validate()?;
		if let Some(ref val) = self.cdtr_agt_acct { val.validate()? }
		self.rsn.validate()?;
		Ok(())
	}
}


// CompensationMethod1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CompensationMethod1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "NOCP") )]
	CodeNOCP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DBTD") )]
	CodeDBTD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INVD") )]
	CodeINVD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DDBT") )]
	CodeDDBT,
}

impl CompensationMethod1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CompensationReason1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompensationReason1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl CompensationReason1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// CompensationRequest1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompensationRequest1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CompstnAcct", skip_serializing_if = "Option::is_none") )]
	pub compstn_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prd") )]
	pub prd: DatePeriod2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XpctdValDt", skip_serializing_if = "Option::is_none") )]
	pub xpctd_val_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstRate", skip_serializing_if = "Option::is_none") )]
	pub intrst_rate: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<Vec<String>>,
}

impl CompensationRequest1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.compstn_acct { val.validate()? }
		self.prd.validate()?;
		if let Some(ref val) = self.amt { val.validate()? }
		if let Some(ref vec) = self.rsn {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "rsn is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 140 {
					return Err(ValidationError::new(1002, "rsn exceeds the maximum length of 140".to_string()));
				}
			}
		}
		Ok(())
	}
}


// CompensationResponse1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CompensationResponse1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Grantd") )]
	pub grantd: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitlAmt", skip_serializing_if = "Option::is_none") )]
	pub initl_amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PdChrgs", skip_serializing_if = "Option::is_none") )]
	pub pd_chrgs: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AmtDue", skip_serializing_if = "Option::is_none") )]
	pub amt_due: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XpctdValDt", skip_serializing_if = "Option::is_none") )]
	pub xpctd_val_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prd", skip_serializing_if = "Option::is_none") )]
	pub prd: Option<DatePeriod2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstRate", skip_serializing_if = "Option::is_none") )]
	pub intrst_rate: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<String>,
}

impl CompensationResponse1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.initl_amt { val.validate()? }
		if let Some(ref val) = self.pd_chrgs { val.validate()? }
		if let Some(ref val) = self.amt_due { val.validate()? }
		if let Some(ref val) = self.prd { val.validate()? }
		if let Some(ref val) = self.rsn {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rsn is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "rsn exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// ConcentrationAccount1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ConcentrationAccount1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "InFlow") )]
	pub in_flow: Flows1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OutFlow") )]
	pub out_flow: Flows1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndOfDay") )]
	pub end_of_day: AmountAndDirection102,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PeakCdt") )]
	pub peak_cdt: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PeakDbt") )]
	pub peak_dbt: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LatePmtConf") )]
	pub late_pmt_conf: String,
}

impl ConcentrationAccount1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.in_flow.validate()?;
		self.out_flow.validate()?;
		self.end_of_day.validate()?;
		self.peak_cdt.validate()?;
		self.peak_dbt.validate()?;
		let pattern = Regex::new("[0-9]{1,10}").unwrap();
		if !pattern.is_match(&self.late_pmt_conf) {
			return Err(ValidationError::new(1005, "late_pmt_conf does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// ConcentrationAgent1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ConcentrationAgent1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Acct") )]
	pub acct: Vec<ConcentrationAccount1>,
}

impl ConcentrationAgent1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
		if !pattern.is_match(&self.id) {
			return Err(ValidationError::new(1005, "id does not match the required pattern".to_string()));
		}
		for item in &self.acct { item.validate()? }
		Ok(())
	}
}


// ConductClassification1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ConductClassification1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "NSTA") )]
	CodeNSTA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RCLT") )]
	CodeRCLT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "STAN") )]
	CodeSTAN,
}

impl ConductClassification1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ConfirmationType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ConfirmationType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<AccountManagementType2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl ConfirmationType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// ConsolidationType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ConsolidationType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<ConsolidationType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl ConsolidationType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// ConsolidationType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ConsolidationType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "GENL") )]
	CodeGENL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PART") )]
	CodePART,
}

impl ConsolidationType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Contact13 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Contact13 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NmPrfx", skip_serializing_if = "Option::is_none") )]
	pub nm_prfx: Option<NamePrefix2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PhneNb", skip_serializing_if = "Option::is_none") )]
	pub phne_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MobNb", skip_serializing_if = "Option::is_none") )]
	pub mob_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FaxNb", skip_serializing_if = "Option::is_none") )]
	pub fax_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "URLAdr", skip_serializing_if = "Option::is_none") )]
	pub url_adr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EmailAdr", skip_serializing_if = "Option::is_none") )]
	pub email_adr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EmailPurp", skip_serializing_if = "Option::is_none") )]
	pub email_purp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "JobTitl", skip_serializing_if = "Option::is_none") )]
	pub job_titl: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rspnsblty", skip_serializing_if = "Option::is_none") )]
	pub rspnsblty: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dept", skip_serializing_if = "Option::is_none") )]
	pub dept: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<Vec<OtherContact1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrefrdMtd", skip_serializing_if = "Option::is_none") )]
	pub prefrd_mtd: Option<PreferredContactMethod2Code>,
}

impl Contact13 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nm_prfx { val.validate()? }
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.phne_nb {
			let pattern = Regex::new("\\+[0-9]{1,3}-[0-9()+\\-]{1,30}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "phne_nb does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.mob_nb {
			let pattern = Regex::new("\\+[0-9]{1,3}-[0-9()+\\-]{1,30}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "mob_nb does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.fax_nb {
			let pattern = Regex::new("\\+[0-9]{1,3}-[0-9()+\\-]{1,30}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "fax_nb does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.url_adr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "url_adr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 2048 {
				return Err(ValidationError::new(1002, "url_adr exceeds the maximum length of 2048".to_string()));
			}
		}
		if let Some(ref val) = self.email_adr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "email_adr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 256 {
				return Err(ValidationError::new(1002, "email_adr exceeds the maximum length of 256".to_string()));
			}
		}
		if let Some(ref val) = self.email_purp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "email_purp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "email_purp exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.job_titl {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "job_titl is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "job_titl exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.rspnsblty {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rspnsblty is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "rspnsblty exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.dept {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "dept is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "dept exceeds the maximum length of 70".to_string()));
			}
		}
		if let Some(ref vec) = self.othr { for item in vec { item.validate()? } }
		if let Some(ref val) = self.prefrd_mtd { val.validate()? }
		Ok(())
	}
}


// Contact14 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Contact14 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NmPrfx", skip_serializing_if = "Option::is_none") )]
	pub nm_prfx: Option<NamePrefix2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PhneNb", skip_serializing_if = "Option::is_none") )]
	pub phne_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MobNb", skip_serializing_if = "Option::is_none") )]
	pub mob_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FaxNb", skip_serializing_if = "Option::is_none") )]
	pub fax_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "URLAdr", skip_serializing_if = "Option::is_none") )]
	pub url_adr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EmailAdr", skip_serializing_if = "Option::is_none") )]
	pub email_adr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EmailPurp", skip_serializing_if = "Option::is_none") )]
	pub email_purp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "JobTitl", skip_serializing_if = "Option::is_none") )]
	pub job_titl: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rspnsblty", skip_serializing_if = "Option::is_none") )]
	pub rspnsblty: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dept", skip_serializing_if = "Option::is_none") )]
	pub dept: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<Vec<OtherContact1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrefrdMtd", skip_serializing_if = "Option::is_none") )]
	pub prefrd_mtd: Option<PreferredContactMethod2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldFr", skip_serializing_if = "Option::is_none") )]
	pub vld_fr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldTo", skip_serializing_if = "Option::is_none") )]
	pub vld_to: Option<String>,
}

impl Contact14 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nm_prfx { val.validate()? }
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.phne_nb {
			let pattern = Regex::new("\\+[0-9]{1,3}-[0-9()+\\-]{1,30}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "phne_nb does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.mob_nb {
			let pattern = Regex::new("\\+[0-9]{1,3}-[0-9()+\\-]{1,30}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "mob_nb does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.fax_nb {
			let pattern = Regex::new("\\+[0-9]{1,3}-[0-9()+\\-]{1,30}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "fax_nb does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.url_adr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "url_adr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 2048 {
				return Err(ValidationError::new(1002, "url_adr exceeds the maximum length of 2048".to_string()));
			}
		}
		if let Some(ref val) = self.email_adr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "email_adr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 256 {
				return Err(ValidationError::new(1002, "email_adr exceeds the maximum length of 256".to_string()));
			}
		}
		if let Some(ref val) = self.email_purp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "email_purp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "email_purp exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.job_titl {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "job_titl is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "job_titl exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.rspnsblty {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rspnsblty is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "rspnsblty exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.dept {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "dept is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "dept exceeds the maximum length of 70".to_string()));
			}
		}
		if let Some(ref vec) = self.othr { for item in vec { item.validate()? } }
		if let Some(ref val) = self.prefrd_mtd { val.validate()? }
		Ok(())
	}
}


// Contact4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Contact4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NmPrfx", skip_serializing_if = "Option::is_none") )]
	pub nm_prfx: Option<NamePrefix2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PhneNb", skip_serializing_if = "Option::is_none") )]
	pub phne_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MobNb", skip_serializing_if = "Option::is_none") )]
	pub mob_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FaxNb", skip_serializing_if = "Option::is_none") )]
	pub fax_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EmailAdr", skip_serializing_if = "Option::is_none") )]
	pub email_adr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EmailPurp", skip_serializing_if = "Option::is_none") )]
	pub email_purp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "JobTitl", skip_serializing_if = "Option::is_none") )]
	pub job_titl: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rspnsblty", skip_serializing_if = "Option::is_none") )]
	pub rspnsblty: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dept", skip_serializing_if = "Option::is_none") )]
	pub dept: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<Vec<OtherContact1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrefrdMtd", skip_serializing_if = "Option::is_none") )]
	pub prefrd_mtd: Option<PreferredContactMethod1Code>,
}

impl Contact4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nm_prfx { val.validate()? }
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.phne_nb {
			let pattern = Regex::new("\\+[0-9]{1,3}-[0-9()+\\-]{1,30}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "phne_nb does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.mob_nb {
			let pattern = Regex::new("\\+[0-9]{1,3}-[0-9()+\\-]{1,30}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "mob_nb does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.fax_nb {
			let pattern = Regex::new("\\+[0-9]{1,3}-[0-9()+\\-]{1,30}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "fax_nb does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.email_adr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "email_adr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 2048 {
				return Err(ValidationError::new(1002, "email_adr exceeds the maximum length of 2048".to_string()));
			}
		}
		if let Some(ref val) = self.email_purp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "email_purp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "email_purp exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.job_titl {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "job_titl is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "job_titl exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.rspnsblty {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rspnsblty is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "rspnsblty exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.dept {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "dept is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "dept exceeds the maximum length of 70".to_string()));
			}
		}
		if let Some(ref vec) = self.othr { for item in vec { item.validate()? } }
		if let Some(ref val) = self.prefrd_mtd { val.validate()? }
		Ok(())
	}
}


// Contact9 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Contact9 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm") )]
	pub nm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PhneNb") )]
	pub phne_nb: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EmailAdr") )]
	pub email_adr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Fctn", skip_serializing_if = "Option::is_none") )]
	pub fctn: Option<String>,
}

impl Contact9 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
		}
		if self.nm.chars().count() > 140 {
			return Err(ValidationError::new(1002, "nm exceeds the maximum length of 140".to_string()));
		}
		let pattern = Regex::new("\\+[0-9]{1,3}-[0-9()+\\-]{1,30}").unwrap();
		if !pattern.is_match(&self.phne_nb) {
			return Err(ValidationError::new(1005, "phne_nb does not match the required pattern".to_string()));
		}
		if self.email_adr.chars().count() < 1 {
			return Err(ValidationError::new(1001, "email_adr is shorter than the minimum length of 1".to_string()));
		}
		if self.email_adr.chars().count() > 256 {
			return Err(ValidationError::new(1002, "email_adr exceeds the maximum length of 256".to_string()));
		}
		if let Some(ref val) = self.fctn {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "fctn is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "fctn exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// ContactAttributes5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ContactAttributes5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm") )]
	pub nm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstlAdr", skip_serializing_if = "Option::is_none") )]
	pub pstl_adr: Option<PostalAddress1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PhneNb", skip_serializing_if = "Option::is_none") )]
	pub phne_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FaxNb", skip_serializing_if = "Option::is_none") )]
	pub fax_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EmailAdr", skip_serializing_if = "Option::is_none") )]
	pub email_adr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "URLAdr", skip_serializing_if = "Option::is_none") )]
	pub url_adr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AnyBIC", skip_serializing_if = "Option::is_none") )]
	pub any_bic: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LEI", skip_serializing_if = "Option::is_none") )]
	pub lei: Option<String>,
}

impl ContactAttributes5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
		}
		if self.nm.chars().count() > 350 {
			return Err(ValidationError::new(1002, "nm exceeds the maximum length of 350".to_string()));
		}
		if let Some(ref val) = self.pstl_adr { val.validate()? }
		if let Some(ref val) = self.phne_nb {
			let pattern = Regex::new("\\+[0-9]{1,3}-[0-9()+\\-]{1,30}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "phne_nb does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.fax_nb {
			let pattern = Regex::new("\\+[0-9]{1,3}-[0-9()+\\-]{1,30}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "fax_nb does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.email_adr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "email_adr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 256 {
				return Err(ValidationError::new(1002, "email_adr exceeds the maximum length of 256".to_string()));
			}
		}
		if let Some(ref val) = self.url_adr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "url_adr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 2048 {
				return Err(ValidationError::new(1002, "url_adr exceeds the maximum length of 2048".to_string()));
			}
		}
		if let Some(ref val) = self.any_bic {
			let pattern = Regex::new("[A-Z0-9]{4,4}[A-Z]{2,2}[A-Z0-9]{2,2}([A-Z0-9]{3,3}){0,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "any_bic does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.lei {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "lei does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// ContactAttributes6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ContactAttributes6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstlAdr", skip_serializing_if = "Option::is_none") )]
	pub pstl_adr: Option<PostalAddress1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PhneNb", skip_serializing_if = "Option::is_none") )]
	pub phne_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FaxNb", skip_serializing_if = "Option::is_none") )]
	pub fax_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EmailAdr", skip_serializing_if = "Option::is_none") )]
	pub email_adr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "URLAdr", skip_serializing_if = "Option::is_none") )]
	pub url_adr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AnyBIC", skip_serializing_if = "Option::is_none") )]
	pub any_bic: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LEI", skip_serializing_if = "Option::is_none") )]
	pub lei: Option<String>,
}

impl ContactAttributes6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.pstl_adr { val.validate()? }
		if let Some(ref val) = self.phne_nb {
			let pattern = Regex::new("\\+[0-9]{1,3}-[0-9()+\\-]{1,30}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "phne_nb does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.fax_nb {
			let pattern = Regex::new("\\+[0-9]{1,3}-[0-9()+\\-]{1,30}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "fax_nb does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.email_adr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "email_adr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 256 {
				return Err(ValidationError::new(1002, "email_adr exceeds the maximum length of 256".to_string()));
			}
		}
		if let Some(ref val) = self.url_adr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "url_adr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 2048 {
				return Err(ValidationError::new(1002, "url_adr exceeds the maximum length of 2048".to_string()));
			}
		}
		if let Some(ref val) = self.any_bic {
			let pattern = Regex::new("[A-Z0-9]{4,4}[A-Z]{2,2}[A-Z0-9]{2,2}([A-Z0-9]{3,3}){0,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "any_bic does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.lei {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "lei does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// ContactDetails2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ContactDetails2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NmPrfx", skip_serializing_if = "Option::is_none") )]
	pub nm_prfx: Option<NamePrefix1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PhneNb", skip_serializing_if = "Option::is_none") )]
	pub phne_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MobNb", skip_serializing_if = "Option::is_none") )]
	pub mob_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FaxNb", skip_serializing_if = "Option::is_none") )]
	pub fax_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EmailAdr", skip_serializing_if = "Option::is_none") )]
	pub email_adr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<String>,
}

impl ContactDetails2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nm_prfx { val.validate()? }
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.phne_nb {
			let pattern = Regex::new("\\+[0-9]{1,3}-[0-9()+\\-]{1,30}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "phne_nb does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.mob_nb {
			let pattern = Regex::new("\\+[0-9]{1,3}-[0-9()+\\-]{1,30}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "mob_nb does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.fax_nb {
			let pattern = Regex::new("\\+[0-9]{1,3}-[0-9()+\\-]{1,30}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "fax_nb does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.email_adr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "email_adr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 2048 {
				return Err(ValidationError::new(1002, "email_adr exceeds the maximum length of 2048".to_string()));
			}
		}
		if let Some(ref val) = self.othr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "othr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "othr exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// ContactDetails4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ContactDetails4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm") )]
	pub nm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PhneNb") )]
	pub phne_nb: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EmailAdr") )]
	pub email_adr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Fctn") )]
	pub fctn: String,
}

impl ContactDetails4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
		}
		if self.nm.chars().count() > 140 {
			return Err(ValidationError::new(1002, "nm exceeds the maximum length of 140".to_string()));
		}
		let pattern = Regex::new("\\+[0-9]{1,3}-[0-9()+\\-]{1,30}").unwrap();
		if !pattern.is_match(&self.phne_nb) {
			return Err(ValidationError::new(1005, "phne_nb does not match the required pattern".to_string()));
		}
		if self.email_adr.chars().count() < 1 {
			return Err(ValidationError::new(1001, "email_adr is shorter than the minimum length of 1".to_string()));
		}
		if self.email_adr.chars().count() > 2048 {
			return Err(ValidationError::new(1002, "email_adr exceeds the maximum length of 2048".to_string()));
		}
		if self.fctn.chars().count() < 1 {
			return Err(ValidationError::new(1001, "fctn is shorter than the minimum length of 1".to_string()));
		}
		if self.fctn.chars().count() > 140 {
			return Err(ValidationError::new(1002, "fctn exceeds the maximum length of 140".to_string()));
		}
		Ok(())
	}
}


// ContactIdentificationAndAddress1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ContactIdentificationAndAddress1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Role") )]
	pub role: PaymentRole1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ComAdr") )]
	pub com_adr: CommunicationAddress8,
}

impl ContactIdentificationAndAddress1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 35".to_string()));
			}
		}
		self.role.validate()?;
		self.com_adr.validate()?;
		Ok(())
	}
}


// ContactIdentificationAndAddress2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ContactIdentificationAndAddress2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Role") )]
	pub role: PaymentRole1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ComAdr") )]
	pub com_adr: CommunicationAddress10,
}

impl ContactIdentificationAndAddress2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 35".to_string()));
			}
		}
		self.role.validate()?;
		self.com_adr.validate()?;
		Ok(())
	}
}


// ContractBalance1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ContractBalance1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: ContractBalanceType1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbtInd") )]
	pub cdt_dbt_ind: CreditDebit3Code,
}

impl ContractBalance1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tp.validate()?;
		self.amt.validate()?;
		self.cdt_dbt_ind.validate()?;
		Ok(())
	}
}


// ContractBalanceType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ContractBalanceType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl ContractBalanceType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// ContractCessionData2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ContractCessionData2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pty") )]
	pub pty: TradeParty6,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DocNb", skip_serializing_if = "Option::is_none") )]
	pub doc_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DocDt", skip_serializing_if = "Option::is_none") )]
	pub doc_dt: Option<String>,
}

impl ContractCessionData2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pty.validate()?;
		if let Some(ref val) = self.doc_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "doc_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "doc_nb exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// ContractClosureReason1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ContractClosureReason1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl ContractClosureReason1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// ContractCollateral1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ContractCollateral1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlAmt") )]
	pub ttl_amt: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollDesc", skip_serializing_if = "Option::is_none") )]
	pub coll_desc: Option<Vec<CashCollateral5>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
}

impl ContractCollateral1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.ttl_amt.validate()?;
		if let Some(ref vec) = self.coll_desc { for item in vec { item.validate()? } }
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 1025 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 1025".to_string()));
			}
		}
		Ok(())
	}
}


// ContractDocument1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ContractDocument1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ref") )]
	pub ref_attr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SgnOffDt", skip_serializing_if = "Option::is_none") )]
	pub sgn_off_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Vrsn", skip_serializing_if = "Option::is_none") )]
	pub vrsn: Option<String>,
}

impl ContractDocument1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.ref_attr.chars().count() < 1 {
			return Err(ValidationError::new(1001, "ref_attr is shorter than the minimum length of 1".to_string()));
		}
		if self.ref_attr.chars().count() > 35 {
			return Err(ValidationError::new(1002, "ref_attr exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.vrsn {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "vrsn is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 6 {
				return Err(ValidationError::new(1002, "vrsn exceeds the maximum length of 6".to_string()));
			}
		}
		Ok(())
	}
}


// ContractForDifference2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ContractForDifference2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "UndrlygTp") )]
	pub undrlyg_tp: UnderlyingContractForDifferenceType3Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtnlCcy1", skip_serializing_if = "Option::is_none") )]
	pub ntnl_ccy1: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtnlCcy2", skip_serializing_if = "Option::is_none") )]
	pub ntnl_ccy2: Option<String>,
}

impl ContractForDifference2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.undrlyg_tp.validate()?;
		if let Some(ref val) = self.ntnl_ccy1 {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ntnl_ccy1 does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.ntnl_ccy2 {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ntnl_ccy2 does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// ContractMatchingCriteria3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ContractMatchingCriteria3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISIN", skip_serializing_if = "Option::is_none") )]
	pub isin: Option<CompareISINIdentifier2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnqPdctIdr", skip_serializing_if = "Option::is_none") )]
	pub unq_pdct_idr: Option<CompareUniqueProductIdentifier2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AltrntvInstrmId", skip_serializing_if = "Option::is_none") )]
	pub altrntv_instrm_id: Option<CompareText1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PdctClssfctn", skip_serializing_if = "Option::is_none") )]
	pub pdct_clssfctn: Option<CompareCFIIdentifier3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctTp", skip_serializing_if = "Option::is_none") )]
	pub ctrct_tp: Option<CompareFinancialInstrumentContractType1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AsstClss", skip_serializing_if = "Option::is_none") )]
	pub asst_clss: Option<CompareAssetClass1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DerivBasedOnCrptAsst", skip_serializing_if = "Option::is_none") )]
	pub deriv_based_on_crpt_asst: Option<CompareTrueFalseIndicator3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UndrlygInstrm", skip_serializing_if = "Option::is_none") )]
	pub undrlyg_instrm: Option<CompareUnderlyingInstrument3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmCcy", skip_serializing_if = "Option::is_none") )]
	pub sttlm_ccy: Option<CompareActiveOrHistoricCurrencyCode1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmCcyScndLeg", skip_serializing_if = "Option::is_none") )]
	pub sttlm_ccy_scnd_leg: Option<CompareActiveOrHistoricCurrencyCode1>,
}

impl ContractMatchingCriteria3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.isin { val.validate()? }
		if let Some(ref val) = self.unq_pdct_idr { val.validate()? }
		if let Some(ref val) = self.altrntv_instrm_id { val.validate()? }
		if let Some(ref val) = self.pdct_clssfctn { val.validate()? }
		if let Some(ref val) = self.ctrct_tp { val.validate()? }
		if let Some(ref val) = self.asst_clss { val.validate()? }
		if let Some(ref val) = self.deriv_based_on_crpt_asst { val.validate()? }
		if let Some(ref val) = self.undrlyg_instrm { val.validate()? }
		if let Some(ref val) = self.sttlm_ccy { val.validate()? }
		if let Some(ref val) = self.sttlm_ccy_scnd_leg { val.validate()? }
		Ok(())
	}
}


// ContractModification3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ContractModification3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ActnTp") )]
	pub actn_tp: TransactionOperationType6Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Lvl", skip_serializing_if = "Option::is_none") )]
	pub lvl: Option<ModificationLevel1Code>,
}

impl ContractModification3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.actn_tp.validate()?;
		if let Some(ref val) = self.lvl { val.validate()? }
		Ok(())
	}
}


// ContractModification8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ContractModification8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ActnTp") )]
	pub actn_tp: TransactionOperationType11Code,
}

impl ContractModification8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.actn_tp.validate()?;
		Ok(())
	}
}


// ContractModification9 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ContractModification9 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ActnTp", skip_serializing_if = "Option::is_none") )]
	pub actn_tp: Option<TransactionOperationType10Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Lvl", skip_serializing_if = "Option::is_none") )]
	pub lvl: Option<ModificationLevel1Code>,
}

impl ContractModification9 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.actn_tp { val.validate()? }
		if let Some(ref val) = self.lvl { val.validate()? }
		Ok(())
	}
}


// ContractReference1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ContractReference1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<DocumentType1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ref") )]
	pub ref_attr: String,
}

impl ContractReference1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tp { val.validate()? }
		if self.ref_attr.chars().count() < 1 {
			return Err(ValidationError::new(1001, "ref_attr is shorter than the minimum length of 1".to_string()));
		}
		if self.ref_attr.chars().count() > 500 {
			return Err(ValidationError::new(1002, "ref_attr exceeds the maximum length of 500".to_string()));
		}
		Ok(())
	}
}


// ContractRegistration7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ContractRegistration7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctRegnId") )]
	pub ctrct_regn_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgPty") )]
	pub rptg_pty: TradeParty6,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegnAgt") )]
	pub regn_agt: BranchAndFinancialInstitutionIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctRegnOpng") )]
	pub ctrct_regn_opng: Vec<ContractRegistration8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl ContractRegistration7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.ctrct_regn_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "ctrct_regn_id is shorter than the minimum length of 1".to_string()));
		}
		if self.ctrct_regn_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "ctrct_regn_id exceeds the maximum length of 35".to_string()));
		}
		self.rptg_pty.validate()?;
		self.regn_agt.validate()?;
		for item in &self.ctrct_regn_opng { item.validate()? }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// ContractRegistration8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ContractRegistration8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctRegnOpngId") )]
	pub ctrct_regn_opng_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prty") )]
	pub prty: Priority2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctrct") )]
	pub ctrct: UnderlyingContract4Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctBal", skip_serializing_if = "Option::is_none") )]
	pub ctrct_bal: Option<Vec<ContractBalance1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtSchdlTp", skip_serializing_if = "Option::is_none") )]
	pub pmt_schdl_tp: Option<PaymentScheduleType2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsRegnId", skip_serializing_if = "Option::is_none") )]
	pub prvs_regn_id: Option<Vec<DocumentIdentification22>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Attchmnt", skip_serializing_if = "Option::is_none") )]
	pub attchmnt: Option<Vec<DocumentGeneralInformation5>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl ContractRegistration8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.ctrct_regn_opng_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "ctrct_regn_opng_id is shorter than the minimum length of 1".to_string()));
		}
		if self.ctrct_regn_opng_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "ctrct_regn_opng_id exceeds the maximum length of 35".to_string()));
		}
		self.prty.validate()?;
		self.ctrct.validate()?;
		if let Some(ref vec) = self.ctrct_bal { for item in vec { item.validate()? } }
		if let Some(ref val) = self.pmt_schdl_tp { val.validate()? }
		if let Some(ref vec) = self.prvs_regn_id { for item in vec { item.validate()? } }
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 1025 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 1025".to_string()));
			}
		}
		if let Some(ref vec) = self.attchmnt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// ContractRegistrationReference2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ContractRegistrationReference2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegdCtrctId", skip_serializing_if = "Option::is_none") )]
	pub regd_ctrct_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctrct", skip_serializing_if = "Option::is_none") )]
	pub ctrct: Option<DocumentIdentification35>,
}

impl ContractRegistrationReference2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.regd_ctrct_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "regd_ctrct_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "regd_ctrct_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.ctrct { val.validate()? }
		Ok(())
	}
}


// ContractRegistrationStatement4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ContractRegistrationStatement4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "StmtId", skip_serializing_if = "Option::is_none") )]
	pub stmt_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgPty") )]
	pub rptg_pty: TradeParty6,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegnAgt") )]
	pub regn_agt: BranchAndFinancialInstitutionIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgPrd") )]
	pub rptg_prd: ReportingPeriod4,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegdCtrct") )]
	pub regd_ctrct: RegisteredContract18,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxJrnl", skip_serializing_if = "Option::is_none") )]
	pub tx_jrnl: Option<Vec<TransactionCertificate4>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SpprtgDocJrnl", skip_serializing_if = "Option::is_none") )]
	pub spprtg_doc_jrnl: Option<Vec<SupportingDocument4>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlSpprtgDocJrnl", skip_serializing_if = "Option::is_none") )]
	pub addtl_spprtg_doc_jrnl: Option<Vec<SupportingDocument4>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RgltryRuleVldtn", skip_serializing_if = "Option::is_none") )]
	pub rgltry_rule_vldtn: Option<Vec<GenericValidationRuleIdentification1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlCtrctTrnvrSum") )]
	pub ttl_ctrct_trnvr_sum: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl ContractRegistrationStatement4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.stmt_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "stmt_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "stmt_id exceeds the maximum length of 35".to_string()));
			}
		}
		self.rptg_pty.validate()?;
		self.regn_agt.validate()?;
		self.rptg_prd.validate()?;
		self.regd_ctrct.validate()?;
		if let Some(ref vec) = self.tx_jrnl { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.spprtg_doc_jrnl { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.addtl_spprtg_doc_jrnl { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.rgltry_rule_vldtn { for item in vec { item.validate()? } }
		self.ttl_ctrct_trnvr_sum.validate()?;
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// ContractRegistrationStatementCriteria1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ContractRegistrationStatementCriteria1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxJrnl", skip_serializing_if = "Option::is_none") )]
	pub tx_jrnl: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SpprtgDocJrnl", skip_serializing_if = "Option::is_none") )]
	pub spprtg_doc_jrnl: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlSpprtgDocJrnl", skip_serializing_if = "Option::is_none") )]
	pub addtl_spprtg_doc_jrnl: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RgltryRuleVldtn", skip_serializing_if = "Option::is_none") )]
	pub rgltry_rule_vldtn: Option<bool>,
}

impl ContractRegistrationStatementCriteria1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ContractRegistrationStatementRequest3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ContractRegistrationStatementRequest3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "StmtReqId") )]
	pub stmt_req_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgPrd") )]
	pub rptg_prd: ReportingPeriod4,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgPty") )]
	pub rptg_pty: TradeParty6,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegnAgt") )]
	pub regn_agt: BranchAndFinancialInstitutionIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegdCtrctId") )]
	pub regd_ctrct_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RtrCrit", skip_serializing_if = "Option::is_none") )]
	pub rtr_crit: Option<ContractRegistrationStatementCriteria1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl ContractRegistrationStatementRequest3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.stmt_req_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "stmt_req_id is shorter than the minimum length of 1".to_string()));
		}
		if self.stmt_req_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "stmt_req_id exceeds the maximum length of 35".to_string()));
		}
		self.rptg_prd.validate()?;
		self.rptg_pty.validate()?;
		self.regn_agt.validate()?;
		if self.regd_ctrct_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "regd_ctrct_id is shorter than the minimum length of 1".to_string()));
		}
		if self.regd_ctrct_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "regd_ctrct_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.rtr_crit { val.validate()? }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// ContractSize1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ContractSize1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "LotSz") )]
	pub lot_sz: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Unit", skip_serializing_if = "Option::is_none") )]
	pub unit: Option<UnitOfMeasure5Choice>,
}

impl ContractSize1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.lot_sz < 1.000000 {
			return Err(ValidationError::new(1003, "lot_sz is less than the minimum value of 1.000000".to_string()));
		}
		if let Some(ref val) = self.unit { val.validate()? }
		Ok(())
	}
}


// ContractTerm6Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ContractTerm6Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Opn", skip_serializing_if = "Option::is_none") )]
	pub opn: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Fxd", skip_serializing_if = "Option::is_none") )]
	pub fxd: Option<TimeToMaturity2Choice>,
}

impl ContractTerm6Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.fxd { val.validate()? }
		Ok(())
	}
}


// ContractTerm7Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ContractTerm7Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Opn", skip_serializing_if = "Option::is_none") )]
	pub opn: Option<FixedOpenTermContract2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Fxd", skip_serializing_if = "Option::is_none") )]
	pub fxd: Option<FixedOpenTermContract2>,
}

impl ContractTerm7Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.opn { val.validate()? }
		if let Some(ref val) = self.fxd { val.validate()? }
		Ok(())
	}
}


// ContractType15 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ContractType15 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctTp", skip_serializing_if = "Option::is_none") )]
	pub ctrct_tp: Option<FinancialInstrumentContractType2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AsstClss", skip_serializing_if = "Option::is_none") )]
	pub asst_clss: Option<ProductType4Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PdctClssfctn", skip_serializing_if = "Option::is_none") )]
	pub pdct_clssfctn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PdctId", skip_serializing_if = "Option::is_none") )]
	pub pdct_id: Option<SecurityIdentification46>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UndrlygInstrm", skip_serializing_if = "Option::is_none") )]
	pub undrlyg_instrm: Option<SecurityIdentification41Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UndrlygAsstTradgPltfmIdr", skip_serializing_if = "Option::is_none") )]
	pub undrlyg_asst_tradg_pltfm_idr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UndrlygAsstPricSrc", skip_serializing_if = "Option::is_none") )]
	pub undrlyg_asst_pric_src: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmCcy", skip_serializing_if = "Option::is_none") )]
	pub sttlm_ccy: Option<CurrencyExchange23>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmCcyScndLeg", skip_serializing_if = "Option::is_none") )]
	pub sttlm_ccy_scnd_leg: Option<CurrencyExchange23>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PlcOfSttlm", skip_serializing_if = "Option::is_none") )]
	pub plc_of_sttlm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DerivBasedOnCrptAsst", skip_serializing_if = "Option::is_none") )]
	pub deriv_based_on_crpt_asst: Option<bool>,
}

impl ContractType15 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ctrct_tp { val.validate()? }
		if let Some(ref val) = self.asst_clss { val.validate()? }
		if let Some(ref val) = self.pdct_clssfctn {
			let pattern = Regex::new("[A-Z]{6,6}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "pdct_clssfctn does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.pdct_id { val.validate()? }
		if let Some(ref val) = self.undrlyg_instrm { val.validate()? }
		if let Some(ref val) = self.undrlyg_asst_tradg_pltfm_idr {
			let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "undrlyg_asst_tradg_pltfm_idr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.undrlyg_asst_pric_src {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "undrlyg_asst_pric_src is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 50 {
				return Err(ValidationError::new(1002, "undrlyg_asst_pric_src exceeds the maximum length of 50".to_string()));
			}
		}
		if let Some(ref val) = self.sttlm_ccy { val.validate()? }
		if let Some(ref val) = self.sttlm_ccy_scnd_leg { val.validate()? }
		if let Some(ref val) = self.plc_of_sttlm {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "plc_of_sttlm does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// ContractValuationData8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ContractValuationData8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctVal", skip_serializing_if = "Option::is_none") )]
	pub ctrct_val: Option<AmountAndDirection109>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TmStmp", skip_serializing_if = "Option::is_none") )]
	pub tm_stmp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<ValuationType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dlta", skip_serializing_if = "Option::is_none") )]
	pub dlta: Option<f64>,
}

impl ContractValuationData8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ctrct_val { val.validate()? }
		if let Some(ref val) = self.tp { val.validate()? }
		Ok(())
	}
}


// ControlData1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ControlData1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfTxs") )]
	pub nb_of_txs: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrlSum", skip_serializing_if = "Option::is_none") )]
	pub ctrl_sum: Option<f64>,
}

impl ControlData1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[0-9]{1,15}").unwrap();
		if !pattern.is_match(&self.nb_of_txs) {
			return Err(ValidationError::new(1005, "nb_of_txs does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// CopyDuplicate1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CopyDuplicate1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CODU") )]
	CodeCODU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "COPY") )]
	CodeCOPY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DUPL") )]
	CodeDUPL,
}

impl CopyDuplicate1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CorporateAction9 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CorporateAction9 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "EvtTp") )]
	pub evt_tp: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EvtId") )]
	pub evt_id: String,
}

impl CorporateAction9 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.evt_tp.chars().count() < 1 {
			return Err(ValidationError::new(1001, "evt_tp is shorter than the minimum length of 1".to_string()));
		}
		if self.evt_tp.chars().count() > 35 {
			return Err(ValidationError::new(1002, "evt_tp exceeds the maximum length of 35".to_string()));
		}
		if self.evt_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "evt_id is shorter than the minimum length of 1".to_string()));
		}
		if self.evt_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "evt_id exceeds the maximum length of 35".to_string()));
		}
		Ok(())
	}
}


// CorporateSectorCriteria5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CorporateSectorCriteria5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FISctr", skip_serializing_if = "Option::is_none") )]
	pub fi_sctr: Option<Vec<FinancialPartySectorType2Code>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NFISctr", skip_serializing_if = "Option::is_none") )]
	pub nfi_sctr: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NotRptd", skip_serializing_if = "Option::is_none") )]
	pub not_rptd: Option<NotReported1Code>,
}

impl CorporateSectorCriteria5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.fi_sctr { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.nfi_sctr {
			for item in vec {
				let pattern = Regex::new("[A-U]{1,1}").unwrap();
				if !pattern.is_match(&item) {
					return Err(ValidationError::new(1005, "nfi_sctr does not match the required pattern".to_string()));
				}
			}
		}
		if let Some(ref val) = self.not_rptd { val.validate()? }
		Ok(())
	}
}


// CorporateSectorCriteria6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CorporateSectorCriteria6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FISctr", skip_serializing_if = "Option::is_none") )]
	pub fi_sctr: Option<Vec<FinancialPartySectorType2Code>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NFISctr", skip_serializing_if = "Option::is_none") )]
	pub nfi_sctr: Option<Vec<NonFinancialPartySector1Code>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NotRptd", skip_serializing_if = "Option::is_none") )]
	pub not_rptd: Option<NotReported1Code>,
}

impl CorporateSectorCriteria6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.fi_sctr { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.nfi_sctr { for item in vec { item.validate()? } }
		if let Some(ref val) = self.not_rptd { val.validate()? }
		Ok(())
	}
}


// CorrectiveGroupInformation1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CorrectiveGroupInformation1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgNmId") )]
	pub msg_nm_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm", skip_serializing_if = "Option::is_none") )]
	pub cre_dt_tm: Option<String>,
}

impl CorrectiveGroupInformation1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		if self.msg_nm_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_nm_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_nm_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_nm_id exceeds the maximum length of 35".to_string()));
		}
		Ok(())
	}
}


// CorrectiveInterbankTransaction3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CorrectiveInterbankTransaction3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "GrpHdr", skip_serializing_if = "Option::is_none") )]
	pub grp_hdr: Option<CorrectiveGroupInformation1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrId", skip_serializing_if = "Option::is_none") )]
	pub instr_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndToEndId", skip_serializing_if = "Option::is_none") )]
	pub end_to_end_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxId", skip_serializing_if = "Option::is_none") )]
	pub tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UETR", skip_serializing_if = "Option::is_none") )]
	pub uetr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBkSttlmAmt") )]
	pub intr_bk_sttlm_amt: ActiveOrHistoricCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBkSttlmDt") )]
	pub intr_bk_sttlm_dt: String,
}

impl CorrectiveInterbankTransaction3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.grp_hdr { val.validate()? }
		if let Some(ref val) = self.instr_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "instr_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "instr_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.end_to_end_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "end_to_end_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "end_to_end_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.uetr {
			let pattern = Regex::new("[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "uetr does not match the required pattern".to_string()));
			}
		}
		self.intr_bk_sttlm_amt.validate()?;
		Ok(())
	}
}


// CorrectivePaymentInitiation5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CorrectivePaymentInitiation5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "GrpHdr", skip_serializing_if = "Option::is_none") )]
	pub grp_hdr: Option<CorrectiveGroupInformation1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtInfId", skip_serializing_if = "Option::is_none") )]
	pub pmt_inf_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrId", skip_serializing_if = "Option::is_none") )]
	pub instr_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndToEndId", skip_serializing_if = "Option::is_none") )]
	pub end_to_end_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UETR", skip_serializing_if = "Option::is_none") )]
	pub uetr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstdAmt") )]
	pub instd_amt: ActiveOrHistoricCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdExctnDt", skip_serializing_if = "Option::is_none") )]
	pub reqd_exctn_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdColltnDt", skip_serializing_if = "Option::is_none") )]
	pub reqd_colltn_dt: Option<String>,
}

impl CorrectivePaymentInitiation5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.grp_hdr { val.validate()? }
		if let Some(ref val) = self.pmt_inf_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pmt_inf_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "pmt_inf_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.instr_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "instr_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "instr_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.end_to_end_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "end_to_end_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "end_to_end_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.uetr {
			let pattern = Regex::new("[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "uetr does not match the required pattern".to_string()));
			}
		}
		self.instd_amt.validate()?;
		if let Some(ref val) = self.reqd_exctn_dt { val.validate()? }
		Ok(())
	}
}


// CorrectiveTransaction5Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CorrectiveTransaction5Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Initn", skip_serializing_if = "Option::is_none") )]
	pub initn: Option<CorrectivePaymentInitiation5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBk", skip_serializing_if = "Option::is_none") )]
	pub intr_bk: Option<CorrectiveInterbankTransaction3>,
}

impl CorrectiveTransaction5Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.initn { val.validate()? }
		if let Some(ref val) = self.intr_bk { val.validate()? }
		Ok(())
	}
}


// CorrespondenceNotification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CorrespondenceNotification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SndrNtfctnId") )]
	pub sndr_ntfctn_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtfctnTp") )]
	pub ntfctn_tp: NotificationType1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtfctnSubTp", skip_serializing_if = "Option::is_none") )]
	pub ntfctn_sub_tp: Option<NotificationSubType1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtfctnNrrtv", skip_serializing_if = "Option::is_none") )]
	pub ntfctn_nrrtv: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NclsdFile", skip_serializing_if = "Option::is_none") )]
	pub nclsd_file: Option<Vec<Document15>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdNtfctnData", skip_serializing_if = "Option::is_none") )]
	pub rltd_ntfctn_data: Option<Vec<RelatedNotificationData1>>,
}

impl CorrespondenceNotification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.sndr_ntfctn_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "sndr_ntfctn_id is shorter than the minimum length of 1".to_string()));
		}
		if self.sndr_ntfctn_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "sndr_ntfctn_id exceeds the maximum length of 35".to_string()));
		}
		self.ntfctn_tp.validate()?;
		if let Some(ref val) = self.ntfctn_sub_tp { val.validate()? }
		if let Some(ref vec) = self.ntfctn_nrrtv {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "ntfctn_nrrtv is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 2000 {
					return Err(ValidationError::new(1002, "ntfctn_nrrtv exceeds the maximum length of 2000".to_string()));
				}
			}
		}
		if let Some(ref vec) = self.nclsd_file { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.rltd_ntfctn_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// CostsAndCharges2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CostsAndCharges2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExAnteRefDt", skip_serializing_if = "Option::is_none") )]
	pub ex_ante_ref_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IndvCostOrChrg") )]
	pub indv_cost_or_chrg: Vec<IndividualCostOrCharge2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<AdditionalInformation15>,
}

impl CostsAndCharges2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		for item in &self.indv_cost_or_chrg { item.validate()? }
		if let Some(ref val) = self.addtl_inf { val.validate()? }
		Ok(())
	}
}


// Counterparty39 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Counterparty39 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgCtrPty") )]
	pub rptg_ctr_pty: OrganisationIdentification15Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrCtrPty") )]
	pub othr_ctr_pty: PartyIdentification236Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NttyRspnsblForRpt", skip_serializing_if = "Option::is_none") )]
	pub ntty_rspnsbl_for_rpt: Option<OrganisationIdentification15Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptSubmitgNtty", skip_serializing_if = "Option::is_none") )]
	pub rpt_submitg_ntty: Option<OrganisationIdentification15Choice>,
}

impl Counterparty39 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.rptg_ctr_pty.validate()?;
		self.othr_ctr_pty.validate()?;
		if let Some(ref val) = self.ntty_rspnsbl_for_rpt { val.validate()? }
		if let Some(ref val) = self.rpt_submitg_ntty { val.validate()? }
		Ok(())
	}
}


// Counterparty45 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Counterparty45 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: PartyIdentification248Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ntr", skip_serializing_if = "Option::is_none") )]
	pub ntr: Option<CounterpartyTradeNature15Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgCpcty", skip_serializing_if = "Option::is_none") )]
	pub tradg_cpcty: Option<TradingCapacity7Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DrctnOrSd", skip_serializing_if = "Option::is_none") )]
	pub drctn_or_sd: Option<Direction4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradrLctn", skip_serializing_if = "Option::is_none") )]
	pub tradr_lctn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BookgLctn", skip_serializing_if = "Option::is_none") )]
	pub bookg_lctn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgXmptn", skip_serializing_if = "Option::is_none") )]
	pub rptg_xmptn: Option<ReportingExemption1>,
}

impl Counterparty45 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.id.validate()?;
		if let Some(ref val) = self.ntr { val.validate()? }
		if let Some(ref val) = self.tradg_cpcty { val.validate()? }
		if let Some(ref val) = self.drctn_or_sd { val.validate()? }
		if let Some(ref val) = self.tradr_lctn {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "tradr_lctn does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.bookg_lctn {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "bookg_lctn does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.rptg_xmptn { val.validate()? }
		Ok(())
	}
}


// Counterparty46 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Counterparty46 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "IdTp", skip_serializing_if = "Option::is_none") )]
	pub id_tp: Option<PartyIdentification248Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ntr", skip_serializing_if = "Option::is_none") )]
	pub ntr: Option<CounterpartyTradeNature15Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgOblgtn", skip_serializing_if = "Option::is_none") )]
	pub rptg_oblgtn: Option<bool>,
}

impl Counterparty46 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.id_tp { val.validate()? }
		if let Some(ref val) = self.ntr { val.validate()? }
		Ok(())
	}
}


// CounterpartyData86 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CounterpartyData86 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgCtrPty", skip_serializing_if = "Option::is_none") )]
	pub rptg_ctr_pty: Option<CounterpartyIdentification10>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrCtrPty", skip_serializing_if = "Option::is_none") )]
	pub othr_ctr_pty: Option<OrganisationIdentification15Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrptyAgt", skip_serializing_if = "Option::is_none") )]
	pub trpty_agt: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AgtLndr", skip_serializing_if = "Option::is_none") )]
	pub agt_lndr: Option<bool>,
}

impl CounterpartyData86 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rptg_ctr_pty { val.validate()? }
		if let Some(ref val) = self.othr_ctr_pty { val.validate()? }
		Ok(())
	}
}


// CounterpartyData87 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CounterpartyData87 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptSubmitgNtty") )]
	pub rpt_submitg_ntty: OrganisationIdentification15Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgCtrPty") )]
	pub rptg_ctr_pty: OrganisationIdentification15Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NttyRspnsblForRpt", skip_serializing_if = "Option::is_none") )]
	pub ntty_rspnsbl_for_rpt: Option<OrganisationIdentification15Choice>,
}

impl CounterpartyData87 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.rpt_submitg_ntty.validate()?;
		self.rptg_ctr_pty.validate()?;
		if let Some(ref val) = self.ntty_rspnsbl_for_rpt { val.validate()? }
		Ok(())
	}
}


// CounterpartyData88 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CounterpartyData88 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgDtTm") )]
	pub rptg_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptSubmitgNtty") )]
	pub rpt_submitg_ntty: OrganisationIdentification15Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPty") )]
	pub ctr_pty: Vec<CounterpartyData89>,
}

impl CounterpartyData88 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.rpt_submitg_ntty.validate()?;
		for item in &self.ctr_pty { item.validate()? }
		Ok(())
	}
}


// CounterpartyData89 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CounterpartyData89 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgCtrPty") )]
	pub rptg_ctr_pty: CounterpartyIdentification11,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrCtrPty") )]
	pub othr_ctr_pty: CounterpartyIdentification12,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NttyRspnsblForRpt", skip_serializing_if = "Option::is_none") )]
	pub ntty_rspnsbl_for_rpt: Option<OrganisationIdentification15Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrPtyData", skip_serializing_if = "Option::is_none") )]
	pub othr_pty_data: Option<TransactionCounterpartyData11>,
}

impl CounterpartyData89 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.rptg_ctr_pty.validate()?;
		self.othr_ctr_pty.validate()?;
		if let Some(ref val) = self.ntty_rspnsbl_for_rpt { val.validate()? }
		if let Some(ref val) = self.othr_pty_data { val.validate()? }
		Ok(())
	}
}


// CounterpartyData91 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CounterpartyData91 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgCtrPty", skip_serializing_if = "Option::is_none") )]
	pub rptg_ctr_pty: Option<OrganisationIdentification15Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrCtrPty", skip_serializing_if = "Option::is_none") )]
	pub othr_ctr_pty: Option<PartyIdentification236Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptSubmitgNtty", skip_serializing_if = "Option::is_none") )]
	pub rpt_submitg_ntty: Option<OrganisationIdentification15Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NttyRspnsblForRpt", skip_serializing_if = "Option::is_none") )]
	pub ntty_rspnsbl_for_rpt: Option<OrganisationIdentification15Choice>,
}

impl CounterpartyData91 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rptg_ctr_pty { val.validate()? }
		if let Some(ref val) = self.othr_ctr_pty { val.validate()? }
		if let Some(ref val) = self.rpt_submitg_ntty { val.validate()? }
		if let Some(ref val) = self.ntty_rspnsbl_for_rpt { val.validate()? }
		Ok(())
	}
}


// CounterpartyData92 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CounterpartyData92 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgCtrPty", skip_serializing_if = "Option::is_none") )]
	pub rptg_ctr_pty: Option<OrganisationIdentification15Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptSubmitgNtty", skip_serializing_if = "Option::is_none") )]
	pub rpt_submitg_ntty: Option<OrganisationIdentification15Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NttyRspnsblForRpt", skip_serializing_if = "Option::is_none") )]
	pub ntty_rspnsbl_for_rpt: Option<OrganisationIdentification15Choice>,
}

impl CounterpartyData92 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rptg_ctr_pty { val.validate()? }
		if let Some(ref val) = self.rpt_submitg_ntty { val.validate()? }
		if let Some(ref val) = self.ntty_rspnsbl_for_rpt { val.validate()? }
		Ok(())
	}
}


// CounterpartyIdentification10 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CounterpartyIdentification10 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<OrganisationIdentification15Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sd", skip_serializing_if = "Option::is_none") )]
	pub sd: Option<CollateralRole1Code>,
}

impl CounterpartyIdentification10 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.id { val.validate()? }
		if let Some(ref val) = self.sd { val.validate()? }
		Ok(())
	}
}


// CounterpartyIdentification11 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CounterpartyIdentification11 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: OrganisationIdentification15Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ntr", skip_serializing_if = "Option::is_none") )]
	pub ntr: Option<CounterpartyTradeNature7Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Brnch", skip_serializing_if = "Option::is_none") )]
	pub brnch: Option<Branch5Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sd", skip_serializing_if = "Option::is_none") )]
	pub sd: Option<CollateralRole1Code>,
}

impl CounterpartyIdentification11 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.id.validate()?;
		if let Some(ref val) = self.ntr { val.validate()? }
		if let Some(ref val) = self.brnch { val.validate()? }
		if let Some(ref val) = self.sd { val.validate()? }
		Ok(())
	}
}


// CounterpartyIdentification12 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CounterpartyIdentification12 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: PartyIdentification236Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Brnch", skip_serializing_if = "Option::is_none") )]
	pub brnch: Option<Branch6Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtryCd", skip_serializing_if = "Option::is_none") )]
	pub ctry_cd: Option<String>,
}

impl CounterpartyIdentification12 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.id.validate()?;
		if let Some(ref val) = self.brnch { val.validate()? }
		if let Some(ref val) = self.ctry_cd {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry_cd does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// CounterpartyIdentification3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CounterpartyIdentification3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "LEI", skip_serializing_if = "Option::is_none") )]
	pub lei: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctrAndLctn", skip_serializing_if = "Option::is_none") )]
	pub sctr_and_lctn: Option<SectorAndLocation1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NmAndLctn", skip_serializing_if = "Option::is_none") )]
	pub nm_and_lctn: Option<NameAndLocation1>,
}

impl CounterpartyIdentification3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.lei {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "lei does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.sctr_and_lctn { val.validate()? }
		if let Some(ref val) = self.nm_and_lctn { val.validate()? }
		Ok(())
	}
}


// CounterpartyMatchingCriteria4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CounterpartyMatchingCriteria4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgCtrPty", skip_serializing_if = "Option::is_none") )]
	pub rptg_ctr_pty: Option<CompareOrganisationIdentification6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrCtrPty", skip_serializing_if = "Option::is_none") )]
	pub othr_ctr_pty: Option<CompareOrganisationIdentification7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtySd", skip_serializing_if = "Option::is_none") )]
	pub ctr_pty_sd: Option<CompareCounterpartySide2>,
}

impl CounterpartyMatchingCriteria4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rptg_ctr_pty { val.validate()? }
		if let Some(ref val) = self.othr_ctr_pty { val.validate()? }
		if let Some(ref val) = self.ctr_pty_sd { val.validate()? }
		Ok(())
	}
}


// CounterpartyMatchingCriteria6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CounterpartyMatchingCriteria6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgCtrPty", skip_serializing_if = "Option::is_none") )]
	pub rptg_ctr_pty: Option<CompareOrganisationIdentification6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrCtrPty", skip_serializing_if = "Option::is_none") )]
	pub othr_ctr_pty: Option<CompareOrganisationIdentification7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DrctnOrSd", skip_serializing_if = "Option::is_none") )]
	pub drctn_or_sd: Option<CompareLegDirection2>,
}

impl CounterpartyMatchingCriteria6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rptg_ctr_pty { val.validate()? }
		if let Some(ref val) = self.othr_ctr_pty { val.validate()? }
		if let Some(ref val) = self.drctn_or_sd { val.validate()? }
		Ok(())
	}
}


// CounterpartySpecificData36 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CounterpartySpecificData36 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPty") )]
	pub ctr_pty: TradeCounterpartyReport20,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Valtn", skip_serializing_if = "Option::is_none") )]
	pub valtn: Option<ContractValuationData8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgTmStmp", skip_serializing_if = "Option::is_none") )]
	pub rptg_tm_stmp: Option<String>,
}

impl CounterpartySpecificData36 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.ctr_pty.validate()?;
		if let Some(ref val) = self.valtn { val.validate()? }
		Ok(())
	}
}


// CounterpartyTradeNature15Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CounterpartyTradeNature15Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FI", skip_serializing_if = "Option::is_none") )]
	pub fi: Option<FinancialInstitutionSector1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NFI", skip_serializing_if = "Option::is_none") )]
	pub nfi: Option<NonFinancialInstitutionSector10>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CntrlCntrPty", skip_serializing_if = "Option::is_none") )]
	pub cntrl_cntr_pty: Option<NoReasonCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<NoReasonCode>,
}

impl CounterpartyTradeNature15Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.fi { val.validate()? }
		if let Some(ref val) = self.nfi { val.validate()? }
		if let Some(ref val) = self.cntrl_cntr_pty { val.validate()? }
		if let Some(ref val) = self.othr { val.validate()? }
		Ok(())
	}
}


// CounterpartyTradeNature7Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CounterpartyTradeNature7Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FI", skip_serializing_if = "Option::is_none") )]
	pub fi: Option<FinancialPartyClassification1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NFI", skip_serializing_if = "Option::is_none") )]
	pub nfi: Option<Vec<FinancialPartyClassification2>>,
}

impl CounterpartyTradeNature7Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.fi { val.validate()? }
		if let Some(ref vec) = self.nfi { for item in vec { item.validate()? } }
		Ok(())
	}
}


// CountryAndResidentialStatusType1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CountryAndResidentialStatusType1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctry") )]
	pub ctry: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ResdtlSts") )]
	pub resdtl_sts: ResidentialStatus1Code,
}

impl CountryAndResidentialStatusType1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{2,2}").unwrap();
		if !pattern.is_match(&self.ctry) {
			return Err(ValidationError::new(1005, "ctry does not match the required pattern".to_string()));
		}
		self.resdtl_sts.validate()?;
		Ok(())
	}
}


// CountryAndResidentialStatusType2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CountryAndResidentialStatusType2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctry") )]
	pub ctry: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ResdtlSts") )]
	pub resdtl_sts: ResidentialStatus1Code,
}

impl CountryAndResidentialStatusType2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{2,2}").unwrap();
		if !pattern.is_match(&self.ctry) {
			return Err(ValidationError::new(1005, "ctry does not match the required pattern".to_string()));
		}
		self.resdtl_sts.validate()?;
		Ok(())
	}
}


// CountryCodeAndName3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CountryCodeAndName3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd") )]
	pub cd: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm") )]
	pub nm: String,
}

impl CountryCodeAndName3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{2,2}").unwrap();
		if !pattern.is_match(&self.cd) {
			return Err(ValidationError::new(1005, "cd does not match the required pattern".to_string()));
		}
		if self.nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
		}
		if self.nm.chars().count() > 70 {
			return Err(ValidationError::new(1002, "nm exceeds the maximum length of 70".to_string()));
		}
		Ok(())
	}
}


// CoverTwoDefaulters1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CoverTwoDefaulters1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cover1Id") )]
	pub cover1_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cover2Id") )]
	pub cover2_id: String,
}

impl CoverTwoDefaulters1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
		if !pattern.is_match(&self.cover1_id) {
			return Err(ValidationError::new(1005, "cover1_id does not match the required pattern".to_string()));
		}
		let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
		if !pattern.is_match(&self.cover2_id) {
			return Err(ValidationError::new(1005, "cover2_id does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// CreditDebit3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CreditDebit3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CRDT") )]
	CodeCRDT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DBIT") )]
	CodeDBIT,
}

impl CreditDebit3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CreditDebitCode ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CreditDebitCode {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CRDT") )]
	CodeCRDT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DBIT") )]
	CodeDBIT,
}

impl CreditDebitCode {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CreditDefaultSwapDerivative5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CreditDefaultSwapDerivative5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "UndrlygCdtDfltSwpId", skip_serializing_if = "Option::is_none") )]
	pub undrlyg_cdt_dflt_swp_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UndrlygCdtDfltSwpIndx") )]
	pub undrlyg_cdt_dflt_swp_indx: CreditDefaultSwapIndex3,
}

impl CreditDefaultSwapDerivative5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.undrlyg_cdt_dflt_swp_id {
			let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "undrlyg_cdt_dflt_swp_id does not match the required pattern".to_string()));
			}
		}
		self.undrlyg_cdt_dflt_swp_indx.validate()?;
		Ok(())
	}
}


// CreditDefaultSwapDerivative6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CreditDefaultSwapDerivative6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "UndrlygCdtDfltSwpId", skip_serializing_if = "Option::is_none") )]
	pub undrlyg_cdt_dflt_swp_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OblgtnId") )]
	pub oblgtn_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SnglNm") )]
	pub sngl_nm: CreditDefaultSwapSingleName2,
}

impl CreditDefaultSwapDerivative6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.undrlyg_cdt_dflt_swp_id {
			let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "undrlyg_cdt_dflt_swp_id does not match the required pattern".to_string()));
			}
		}
		let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
		if !pattern.is_match(&self.oblgtn_id) {
			return Err(ValidationError::new(1005, "oblgtn_id does not match the required pattern".to_string()));
		}
		self.sngl_nm.validate()?;
		Ok(())
	}
}


// CreditDefaultSwapIndex3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CreditDefaultSwapIndex3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "UndrlygIndxId", skip_serializing_if = "Option::is_none") )]
	pub undrlyg_indx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UndrlygIndxNm", skip_serializing_if = "Option::is_none") )]
	pub undrlyg_indx_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Srs", skip_serializing_if = "Option::is_none") )]
	pub srs: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Vrsn", skip_serializing_if = "Option::is_none") )]
	pub vrsn: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RollMnth", skip_serializing_if = "Option::is_none") )]
	pub roll_mnth: Option<Vec<f64>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NxtRollDt", skip_serializing_if = "Option::is_none") )]
	pub nxt_roll_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtnlCcy") )]
	pub ntnl_ccy: String,
}

impl CreditDefaultSwapIndex3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.undrlyg_indx_id {
			let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "undrlyg_indx_id does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.undrlyg_indx_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "undrlyg_indx_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 25 {
				return Err(ValidationError::new(1002, "undrlyg_indx_nm exceeds the maximum length of 25".to_string()));
			}
		}
		if let Some(ref vec) = self.roll_mnth {
			for item in vec {
				if *item < 1.000000 {
					return Err(ValidationError::new(1003, "roll_mnth is less than the minimum value of 1.000000".to_string()));
				}
				if *item > 12.000000 {
					return Err(ValidationError::new(1004, "roll_mnth exceeds the maximum value of 12.000000".to_string()));
				}
			}
		}
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.ntnl_ccy) {
			return Err(ValidationError::new(1005, "ntnl_ccy does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// CreditDefaultSwapSingleName2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CreditDefaultSwapSingleName2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SvrgnIssr") )]
	pub svrgn_issr: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RefPty", skip_serializing_if = "Option::is_none") )]
	pub ref_pty: Option<DerivativePartyIdentification1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtnlCcy") )]
	pub ntnl_ccy: String,
}

impl CreditDefaultSwapSingleName2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ref_pty { val.validate()? }
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.ntnl_ccy) {
			return Err(ValidationError::new(1005, "ntnl_ccy does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// CreditDefaultSwapsDerivative4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CreditDefaultSwapsDerivative4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SnglNmCdtDfltSwp", skip_serializing_if = "Option::is_none") )]
	pub sngl_nm_cdt_dflt_swp: Option<CreditDefaultSwapSingleName2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDfltSwpIndx", skip_serializing_if = "Option::is_none") )]
	pub cdt_dflt_swp_indx: Option<CreditDefaultSwapIndex3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SnglNmCdtDfltSwpDeriv", skip_serializing_if = "Option::is_none") )]
	pub sngl_nm_cdt_dflt_swp_deriv: Option<CreditDefaultSwapDerivative6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDfltSwpIndxDeriv", skip_serializing_if = "Option::is_none") )]
	pub cdt_dflt_swp_indx_deriv: Option<CreditDefaultSwapDerivative5>,
}

impl CreditDefaultSwapsDerivative4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.sngl_nm_cdt_dflt_swp { val.validate()? }
		if let Some(ref val) = self.cdt_dflt_swp_indx { val.validate()? }
		if let Some(ref val) = self.sngl_nm_cdt_dflt_swp_deriv { val.validate()? }
		if let Some(ref val) = self.cdt_dflt_swp_indx_deriv { val.validate()? }
		Ok(())
	}
}


// CreditDerivative4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CreditDerivative4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Snrty", skip_serializing_if = "Option::is_none") )]
	pub snrty: Option<DebtInstrumentSeniorityType2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RefPty", skip_serializing_if = "Option::is_none") )]
	pub ref_pty: Option<DerivativePartyIdentification1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtFrqcy", skip_serializing_if = "Option::is_none") )]
	pub pmt_frqcy: Option<Frequency13Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClctnBsis", skip_serializing_if = "Option::is_none") )]
	pub clctn_bsis: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Srs", skip_serializing_if = "Option::is_none") )]
	pub srs: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Vrsn", skip_serializing_if = "Option::is_none") )]
	pub vrsn: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IndxFctr", skip_serializing_if = "Option::is_none") )]
	pub indx_fctr: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Trch", skip_serializing_if = "Option::is_none") )]
	pub trch: Option<TrancheIndicator3Choice>,
}

impl CreditDerivative4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.snrty { val.validate()? }
		if let Some(ref val) = self.ref_pty { val.validate()? }
		if let Some(ref val) = self.pmt_frqcy { val.validate()? }
		if let Some(ref val) = self.clctn_bsis {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "clctn_bsis is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "clctn_bsis exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.trch { val.validate()? }
		Ok(())
	}
}


// CreditDerivative7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CreditDerivative7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Snrty", skip_serializing_if = "Option::is_none") )]
	pub snrty: Option<DebtInstrumentSeniorityType2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RefPty", skip_serializing_if = "Option::is_none") )]
	pub ref_pty: Option<DerivativePartyIdentification1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtFrqcy", skip_serializing_if = "Option::is_none") )]
	pub pmt_frqcy: Option<Frequency13Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClctnBsis", skip_serializing_if = "Option::is_none") )]
	pub clctn_bsis: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Srs", skip_serializing_if = "Option::is_none") )]
	pub srs: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Vrsn", skip_serializing_if = "Option::is_none") )]
	pub vrsn: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IndxFctr", skip_serializing_if = "Option::is_none") )]
	pub indx_fctr: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrchInd", skip_serializing_if = "Option::is_none") )]
	pub trch_ind: Option<bool>,
}

impl CreditDerivative7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.snrty { val.validate()? }
		if let Some(ref val) = self.ref_pty { val.validate()? }
		if let Some(ref val) = self.pmt_frqcy { val.validate()? }
		if let Some(ref val) = self.clctn_bsis {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "clctn_bsis is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "clctn_bsis exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// CreditLine3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CreditLine3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Incl") )]
	pub incl: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<CreditLineType1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dt", skip_serializing_if = "Option::is_none") )]
	pub dt: Option<DateAndDateTime2Choice>,
}

impl CreditLine3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.amt { val.validate()? }
		if let Some(ref val) = self.dt { val.validate()? }
		Ok(())
	}
}


// CreditLineType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CreditLineType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl CreditLineType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// CreditQuality1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CreditQuality1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "DFIM") )]
	CodeDFIM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EXSP") )]
	CodeEXSP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HIGR") )]
	CodeHIGR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HISP") )]
	CodeHISP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INDF") )]
	CodeINDF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LMGR") )]
	CodeLMGR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NIGS") )]
	CodeNIGS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRIM") )]
	CodePRIM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SURI") )]
	CodeSURI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UMGR") )]
	CodeUMGR,
}

impl CreditQuality1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CreditTransferMandateData1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CreditTransferMandateData1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MndtId", skip_serializing_if = "Option::is_none") )]
	pub mndt_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<MandateTypeInformation2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtOfSgntr", skip_serializing_if = "Option::is_none") )]
	pub dt_of_sgntr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtOfVrfctn", skip_serializing_if = "Option::is_none") )]
	pub dt_of_vrfctn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ElctrncSgntr", skip_serializing_if = "Option::is_none") )]
	pub elctrnc_sgntr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrstPmtDt", skip_serializing_if = "Option::is_none") )]
	pub frst_pmt_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FnlPmtDt", skip_serializing_if = "Option::is_none") )]
	pub fnl_pmt_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Frqcy", skip_serializing_if = "Option::is_none") )]
	pub frqcy: Option<Frequency36Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<MandateSetupReason1Choice>,
}

impl CreditTransferMandateData1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mndt_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mndt_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "mndt_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.elctrnc_sgntr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "elctrnc_sgntr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 10240 {
				return Err(ValidationError::new(1002, "elctrnc_sgntr exceeds the maximum length of 10240".to_string()));
			}
		}
		if let Some(ref val) = self.frqcy { val.validate()? }
		if let Some(ref val) = self.rsn { val.validate()? }
		Ok(())
	}
}


// CreditTransferTransaction59 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CreditTransferTransaction59 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtId") )]
	pub pmt_id: PaymentIdentification6,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtTpInf", skip_serializing_if = "Option::is_none") )]
	pub pmt_tp_inf: Option<PaymentTypeInformation26>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxRateMrkr", skip_serializing_if = "Option::is_none") )]
	pub tax_rate_mrkr: Option<TaxRateMarker1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgBr", skip_serializing_if = "Option::is_none") )]
	pub chrg_br: Option<ChargeBearerType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChqInstr", skip_serializing_if = "Option::is_none") )]
	pub chq_instr: Option<Cheque19>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Frqcy", skip_serializing_if = "Option::is_none") )]
	pub frqcy: Option<Frequency1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrfInstr", skip_serializing_if = "Option::is_none") )]
	pub trf_instr: Option<TransferInstruction1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtDbtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_dbtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt1", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt1: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt2", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt2: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt3", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt3: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgt") )]
	pub cdtr_agt: BranchAndFinancialInstitutionIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cdtr", skip_serializing_if = "Option::is_none") )]
	pub cdtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAcct", skip_serializing_if = "Option::is_none") )]
	pub cdtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtCdtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_cdtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrForCdtrAgt", skip_serializing_if = "Option::is_none") )]
	pub instr_for_cdtr_agt: Option<Vec<InstructionForCreditorAgent3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Purp", skip_serializing_if = "Option::is_none") )]
	pub purp: Option<Purpose2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RgltryRptg", skip_serializing_if = "Option::is_none") )]
	pub rgltry_rptg: Option<Vec<RegulatoryReporting3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tax", skip_serializing_if = "Option::is_none") )]
	pub tax: Option<TaxData1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdRmtInf", skip_serializing_if = "Option::is_none") )]
	pub rltd_rmt_inf: Option<Vec<RemittanceLocation9>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RmtInf", skip_serializing_if = "Option::is_none") )]
	pub rmt_inf: Option<RemittanceInformation22>,
}

impl CreditTransferTransaction59 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pmt_id.validate()?;
		if let Some(ref val) = self.pmt_tp_inf { val.validate()? }
		if let Some(ref val) = self.tax_rate_mrkr { val.validate()? }
		self.amt.validate()?;
		if let Some(ref val) = self.chrg_br { val.validate()? }
		if let Some(ref val) = self.chq_instr { val.validate()? }
		if let Some(ref val) = self.frqcy { val.validate()? }
		if let Some(ref val) = self.trf_instr { val.validate()? }
		if let Some(ref val) = self.ultmt_dbtr { val.validate()? }
		if let Some(ref val) = self.intrmy_agt1 { val.validate()? }
		if let Some(ref val) = self.intrmy_agt2 { val.validate()? }
		if let Some(ref val) = self.intrmy_agt3 { val.validate()? }
		self.cdtr_agt.validate()?;
		if let Some(ref val) = self.cdtr { val.validate()? }
		if let Some(ref val) = self.cdtr_acct { val.validate()? }
		if let Some(ref val) = self.ultmt_cdtr { val.validate()? }
		if let Some(ref vec) = self.instr_for_cdtr_agt { for item in vec { item.validate()? } }
		if let Some(ref val) = self.purp { val.validate()? }
		if let Some(ref vec) = self.rgltry_rptg { for item in vec { item.validate()? } }
		if let Some(ref val) = self.tax { val.validate()? }
		if let Some(ref vec) = self.rltd_rmt_inf { for item in vec { item.validate()? } }
		if let Some(ref val) = self.rmt_inf { val.validate()? }
		Ok(())
	}
}


// CreditTransferTransaction61 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CreditTransferTransaction61 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtId") )]
	pub pmt_id: PaymentIdentification6,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtTpInf", skip_serializing_if = "Option::is_none") )]
	pub pmt_tp_inf: Option<PaymentTypeInformation26>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: AmountType4Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XchgRateInf", skip_serializing_if = "Option::is_none") )]
	pub xchg_rate_inf: Option<ExchangeRate1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgBr", skip_serializing_if = "Option::is_none") )]
	pub chrg_br: Option<ChargeBearerType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MndtRltdInf", skip_serializing_if = "Option::is_none") )]
	pub mndt_rltd_inf: Option<CreditTransferMandateData1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChqInstr", skip_serializing_if = "Option::is_none") )]
	pub chq_instr: Option<Cheque19>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtDbtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_dbtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt1", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt1: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt1Acct", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt1_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt2", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt2: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt2Acct", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt2_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt3", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt3: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt3Acct", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt3_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgt", skip_serializing_if = "Option::is_none") )]
	pub cdtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub cdtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cdtr", skip_serializing_if = "Option::is_none") )]
	pub cdtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAcct", skip_serializing_if = "Option::is_none") )]
	pub cdtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtCdtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_cdtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrForCdtrAgt", skip_serializing_if = "Option::is_none") )]
	pub instr_for_cdtr_agt: Option<Vec<InstructionForCreditorAgent3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrForDbtrAgt", skip_serializing_if = "Option::is_none") )]
	pub instr_for_dbtr_agt: Option<InstructionForDebtorAgent1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Purp", skip_serializing_if = "Option::is_none") )]
	pub purp: Option<Purpose2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RgltryRptg", skip_serializing_if = "Option::is_none") )]
	pub rgltry_rptg: Option<Vec<RegulatoryReporting3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tax", skip_serializing_if = "Option::is_none") )]
	pub tax: Option<TaxData1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdRmtInf", skip_serializing_if = "Option::is_none") )]
	pub rltd_rmt_inf: Option<Vec<RemittanceLocation8>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RmtInf", skip_serializing_if = "Option::is_none") )]
	pub rmt_inf: Option<RemittanceInformation22>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl CreditTransferTransaction61 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pmt_id.validate()?;
		if let Some(ref val) = self.pmt_tp_inf { val.validate()? }
		self.amt.validate()?;
		if let Some(ref val) = self.xchg_rate_inf { val.validate()? }
		if let Some(ref val) = self.chrg_br { val.validate()? }
		if let Some(ref val) = self.mndt_rltd_inf { val.validate()? }
		if let Some(ref val) = self.chq_instr { val.validate()? }
		if let Some(ref val) = self.ultmt_dbtr { val.validate()? }
		if let Some(ref val) = self.intrmy_agt1 { val.validate()? }
		if let Some(ref val) = self.intrmy_agt1_acct { val.validate()? }
		if let Some(ref val) = self.intrmy_agt2 { val.validate()? }
		if let Some(ref val) = self.intrmy_agt2_acct { val.validate()? }
		if let Some(ref val) = self.intrmy_agt3 { val.validate()? }
		if let Some(ref val) = self.intrmy_agt3_acct { val.validate()? }
		if let Some(ref val) = self.cdtr_agt { val.validate()? }
		if let Some(ref val) = self.cdtr_agt_acct { val.validate()? }
		if let Some(ref val) = self.cdtr { val.validate()? }
		if let Some(ref val) = self.cdtr_acct { val.validate()? }
		if let Some(ref val) = self.ultmt_cdtr { val.validate()? }
		if let Some(ref vec) = self.instr_for_cdtr_agt { for item in vec { item.validate()? } }
		if let Some(ref val) = self.instr_for_dbtr_agt { val.validate()? }
		if let Some(ref val) = self.purp { val.validate()? }
		if let Some(ref vec) = self.rgltry_rptg { for item in vec { item.validate()? } }
		if let Some(ref val) = self.tax { val.validate()? }
		if let Some(ref vec) = self.rltd_rmt_inf { for item in vec { item.validate()? } }
		if let Some(ref val) = self.rmt_inf { val.validate()? }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// CreditTransferTransaction62 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CreditTransferTransaction62 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtId") )]
	pub pmt_id: PaymentIdentification13,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtTpInf", skip_serializing_if = "Option::is_none") )]
	pub pmt_tp_inf: Option<PaymentTypeInformation28>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBkSttlmAmt") )]
	pub intr_bk_sttlm_amt: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBkSttlmDt", skip_serializing_if = "Option::is_none") )]
	pub intr_bk_sttlm_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmPrty", skip_serializing_if = "Option::is_none") )]
	pub sttlm_prty: Option<Priority3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmTmIndctn", skip_serializing_if = "Option::is_none") )]
	pub sttlm_tm_indctn: Option<SettlementDateTimeIndication1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmTmReq", skip_serializing_if = "Option::is_none") )]
	pub sttlm_tm_req: Option<SettlementTimeRequest2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsInstgAgt1", skip_serializing_if = "Option::is_none") )]
	pub prvs_instg_agt1: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsInstgAgt1Acct", skip_serializing_if = "Option::is_none") )]
	pub prvs_instg_agt1_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsInstgAgt2", skip_serializing_if = "Option::is_none") )]
	pub prvs_instg_agt2: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsInstgAgt2Acct", skip_serializing_if = "Option::is_none") )]
	pub prvs_instg_agt2_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsInstgAgt3", skip_serializing_if = "Option::is_none") )]
	pub prvs_instg_agt3: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsInstgAgt3Acct", skip_serializing_if = "Option::is_none") )]
	pub prvs_instg_agt3_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstgAgt", skip_serializing_if = "Option::is_none") )]
	pub instg_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstdAgt", skip_serializing_if = "Option::is_none") )]
	pub instd_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt1", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt1: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt1Acct", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt1_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt2", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt2: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt2Acct", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt2_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt3", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt3: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt3Acct", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt3_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtDbtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_dbtr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dbtr") )]
	pub dbtr: BranchAndFinancialInstitutionIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgt", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgt", skip_serializing_if = "Option::is_none") )]
	pub cdtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub cdtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cdtr") )]
	pub cdtr: BranchAndFinancialInstitutionIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAcct", skip_serializing_if = "Option::is_none") )]
	pub cdtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtCdtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_cdtr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrForCdtrAgt", skip_serializing_if = "Option::is_none") )]
	pub instr_for_cdtr_agt: Option<Vec<InstructionForCreditorAgent3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrForNxtAgt", skip_serializing_if = "Option::is_none") )]
	pub instr_for_nxt_agt: Option<Vec<InstructionForNextAgent1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Purp", skip_serializing_if = "Option::is_none") )]
	pub purp: Option<Purpose2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RmtInf", skip_serializing_if = "Option::is_none") )]
	pub rmt_inf: Option<RemittanceInformation2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UndrlygAllcn", skip_serializing_if = "Option::is_none") )]
	pub undrlyg_allcn: Option<Vec<TransactionAllocation1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UndrlygCstmrCdtTrf", skip_serializing_if = "Option::is_none") )]
	pub undrlyg_cstmr_cdt_trf: Option<CreditTransferTransaction63>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl CreditTransferTransaction62 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pmt_id.validate()?;
		if let Some(ref val) = self.pmt_tp_inf { val.validate()? }
		self.intr_bk_sttlm_amt.validate()?;
		if let Some(ref val) = self.sttlm_prty { val.validate()? }
		if let Some(ref val) = self.sttlm_tm_indctn { val.validate()? }
		if let Some(ref val) = self.sttlm_tm_req { val.validate()? }
		if let Some(ref val) = self.prvs_instg_agt1 { val.validate()? }
		if let Some(ref val) = self.prvs_instg_agt1_acct { val.validate()? }
		if let Some(ref val) = self.prvs_instg_agt2 { val.validate()? }
		if let Some(ref val) = self.prvs_instg_agt2_acct { val.validate()? }
		if let Some(ref val) = self.prvs_instg_agt3 { val.validate()? }
		if let Some(ref val) = self.prvs_instg_agt3_acct { val.validate()? }
		if let Some(ref val) = self.instg_agt { val.validate()? }
		if let Some(ref val) = self.instd_agt { val.validate()? }
		if let Some(ref val) = self.intrmy_agt1 { val.validate()? }
		if let Some(ref val) = self.intrmy_agt1_acct { val.validate()? }
		if let Some(ref val) = self.intrmy_agt2 { val.validate()? }
		if let Some(ref val) = self.intrmy_agt2_acct { val.validate()? }
		if let Some(ref val) = self.intrmy_agt3 { val.validate()? }
		if let Some(ref val) = self.intrmy_agt3_acct { val.validate()? }
		if let Some(ref val) = self.ultmt_dbtr { val.validate()? }
		self.dbtr.validate()?;
		if let Some(ref val) = self.dbtr_acct { val.validate()? }
		if let Some(ref val) = self.dbtr_agt { val.validate()? }
		if let Some(ref val) = self.dbtr_agt_acct { val.validate()? }
		if let Some(ref val) = self.cdtr_agt { val.validate()? }
		if let Some(ref val) = self.cdtr_agt_acct { val.validate()? }
		self.cdtr.validate()?;
		if let Some(ref val) = self.cdtr_acct { val.validate()? }
		if let Some(ref val) = self.ultmt_cdtr { val.validate()? }
		if let Some(ref vec) = self.instr_for_cdtr_agt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.instr_for_nxt_agt { for item in vec { item.validate()? } }
		if let Some(ref val) = self.purp { val.validate()? }
		if let Some(ref val) = self.rmt_inf { val.validate()? }
		if let Some(ref vec) = self.undrlyg_allcn { for item in vec { item.validate()? } }
		if let Some(ref val) = self.undrlyg_cstmr_cdt_trf { val.validate()? }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// CreditTransferTransaction63 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CreditTransferTransaction63 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtDbtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_dbtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitgPty", skip_serializing_if = "Option::is_none") )]
	pub initg_pty: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dbtr") )]
	pub dbtr: PartyIdentification272,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgt") )]
	pub dbtr_agt: BranchAndFinancialInstitutionIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsInstgAgt1", skip_serializing_if = "Option::is_none") )]
	pub prvs_instg_agt1: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsInstgAgt1Acct", skip_serializing_if = "Option::is_none") )]
	pub prvs_instg_agt1_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsInstgAgt2", skip_serializing_if = "Option::is_none") )]
	pub prvs_instg_agt2: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsInstgAgt2Acct", skip_serializing_if = "Option::is_none") )]
	pub prvs_instg_agt2_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsInstgAgt3", skip_serializing_if = "Option::is_none") )]
	pub prvs_instg_agt3: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsInstgAgt3Acct", skip_serializing_if = "Option::is_none") )]
	pub prvs_instg_agt3_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt1", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt1: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt1Acct", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt1_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt2", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt2: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt2Acct", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt2_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt3", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt3: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt3Acct", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt3_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgt") )]
	pub cdtr_agt: BranchAndFinancialInstitutionIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub cdtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cdtr") )]
	pub cdtr: PartyIdentification272,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAcct", skip_serializing_if = "Option::is_none") )]
	pub cdtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtCdtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_cdtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrForCdtrAgt", skip_serializing_if = "Option::is_none") )]
	pub instr_for_cdtr_agt: Option<Vec<InstructionForCreditorAgent3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrForNxtAgt", skip_serializing_if = "Option::is_none") )]
	pub instr_for_nxt_agt: Option<Vec<InstructionForNextAgent1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tax", skip_serializing_if = "Option::is_none") )]
	pub tax: Option<TaxData1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RmtInf", skip_serializing_if = "Option::is_none") )]
	pub rmt_inf: Option<RemittanceInformation22>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstdAmt", skip_serializing_if = "Option::is_none") )]
	pub instd_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
}

impl CreditTransferTransaction63 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ultmt_dbtr { val.validate()? }
		if let Some(ref val) = self.initg_pty { val.validate()? }
		self.dbtr.validate()?;
		if let Some(ref val) = self.dbtr_acct { val.validate()? }
		self.dbtr_agt.validate()?;
		if let Some(ref val) = self.dbtr_agt_acct { val.validate()? }
		if let Some(ref val) = self.prvs_instg_agt1 { val.validate()? }
		if let Some(ref val) = self.prvs_instg_agt1_acct { val.validate()? }
		if let Some(ref val) = self.prvs_instg_agt2 { val.validate()? }
		if let Some(ref val) = self.prvs_instg_agt2_acct { val.validate()? }
		if let Some(ref val) = self.prvs_instg_agt3 { val.validate()? }
		if let Some(ref val) = self.prvs_instg_agt3_acct { val.validate()? }
		if let Some(ref val) = self.intrmy_agt1 { val.validate()? }
		if let Some(ref val) = self.intrmy_agt1_acct { val.validate()? }
		if let Some(ref val) = self.intrmy_agt2 { val.validate()? }
		if let Some(ref val) = self.intrmy_agt2_acct { val.validate()? }
		if let Some(ref val) = self.intrmy_agt3 { val.validate()? }
		if let Some(ref val) = self.intrmy_agt3_acct { val.validate()? }
		self.cdtr_agt.validate()?;
		if let Some(ref val) = self.cdtr_agt_acct { val.validate()? }
		self.cdtr.validate()?;
		if let Some(ref val) = self.cdtr_acct { val.validate()? }
		if let Some(ref val) = self.ultmt_cdtr { val.validate()? }
		if let Some(ref vec) = self.instr_for_cdtr_agt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.instr_for_nxt_agt { for item in vec { item.validate()? } }
		if let Some(ref val) = self.tax { val.validate()? }
		if let Some(ref val) = self.rmt_inf { val.validate()? }
		if let Some(ref val) = self.instd_amt { val.validate()? }
		Ok(())
	}
}


// CreditTransferTransaction64 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CreditTransferTransaction64 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtId") )]
	pub pmt_id: PaymentIdentification13,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtTpInf", skip_serializing_if = "Option::is_none") )]
	pub pmt_tp_inf: Option<PaymentTypeInformation28>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBkSttlmAmt") )]
	pub intr_bk_sttlm_amt: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBkSttlmDt", skip_serializing_if = "Option::is_none") )]
	pub intr_bk_sttlm_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmPrty", skip_serializing_if = "Option::is_none") )]
	pub sttlm_prty: Option<Priority3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmTmIndctn", skip_serializing_if = "Option::is_none") )]
	pub sttlm_tm_indctn: Option<SettlementDateTimeIndication1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmTmReq", skip_serializing_if = "Option::is_none") )]
	pub sttlm_tm_req: Option<SettlementTimeRequest2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AccptncDtTm", skip_serializing_if = "Option::is_none") )]
	pub accptnc_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PoolgAdjstmntDt", skip_serializing_if = "Option::is_none") )]
	pub poolg_adjstmnt_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstdAmt", skip_serializing_if = "Option::is_none") )]
	pub instd_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XchgRate", skip_serializing_if = "Option::is_none") )]
	pub xchg_rate: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgBr") )]
	pub chrg_br: ChargeBearerType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsInf", skip_serializing_if = "Option::is_none") )]
	pub chrgs_inf: Option<Vec<Charges16>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MndtRltdInf", skip_serializing_if = "Option::is_none") )]
	pub mndt_rltd_inf: Option<CreditTransferMandateData1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsInstgAgt1", skip_serializing_if = "Option::is_none") )]
	pub prvs_instg_agt1: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsInstgAgt1Acct", skip_serializing_if = "Option::is_none") )]
	pub prvs_instg_agt1_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsInstgAgt2", skip_serializing_if = "Option::is_none") )]
	pub prvs_instg_agt2: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsInstgAgt2Acct", skip_serializing_if = "Option::is_none") )]
	pub prvs_instg_agt2_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsInstgAgt3", skip_serializing_if = "Option::is_none") )]
	pub prvs_instg_agt3: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsInstgAgt3Acct", skip_serializing_if = "Option::is_none") )]
	pub prvs_instg_agt3_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstgAgt", skip_serializing_if = "Option::is_none") )]
	pub instg_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstdAgt", skip_serializing_if = "Option::is_none") )]
	pub instd_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt1", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt1: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt1Acct", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt1_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt2", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt2: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt2Acct", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt2_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt3", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt3: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt3Acct", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt3_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtDbtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_dbtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitgPty", skip_serializing_if = "Option::is_none") )]
	pub initg_pty: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dbtr") )]
	pub dbtr: PartyIdentification272,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgt") )]
	pub dbtr_agt: BranchAndFinancialInstitutionIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgt") )]
	pub cdtr_agt: BranchAndFinancialInstitutionIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub cdtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cdtr") )]
	pub cdtr: PartyIdentification272,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAcct", skip_serializing_if = "Option::is_none") )]
	pub cdtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtCdtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_cdtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrForCdtrAgt", skip_serializing_if = "Option::is_none") )]
	pub instr_for_cdtr_agt: Option<Vec<InstructionForCreditorAgent3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrForNxtAgt", skip_serializing_if = "Option::is_none") )]
	pub instr_for_nxt_agt: Option<Vec<InstructionForNextAgent1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Purp", skip_serializing_if = "Option::is_none") )]
	pub purp: Option<Purpose2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RgltryRptg", skip_serializing_if = "Option::is_none") )]
	pub rgltry_rptg: Option<Vec<RegulatoryReporting3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tax", skip_serializing_if = "Option::is_none") )]
	pub tax: Option<TaxData1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdRmtInf", skip_serializing_if = "Option::is_none") )]
	pub rltd_rmt_inf: Option<Vec<RemittanceLocation8>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RmtInf", skip_serializing_if = "Option::is_none") )]
	pub rmt_inf: Option<RemittanceInformation22>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl CreditTransferTransaction64 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pmt_id.validate()?;
		if let Some(ref val) = self.pmt_tp_inf { val.validate()? }
		self.intr_bk_sttlm_amt.validate()?;
		if let Some(ref val) = self.sttlm_prty { val.validate()? }
		if let Some(ref val) = self.sttlm_tm_indctn { val.validate()? }
		if let Some(ref val) = self.sttlm_tm_req { val.validate()? }
		if let Some(ref val) = self.instd_amt { val.validate()? }
		self.chrg_br.validate()?;
		if let Some(ref vec) = self.chrgs_inf { for item in vec { item.validate()? } }
		if let Some(ref val) = self.mndt_rltd_inf { val.validate()? }
		if let Some(ref val) = self.prvs_instg_agt1 { val.validate()? }
		if let Some(ref val) = self.prvs_instg_agt1_acct { val.validate()? }
		if let Some(ref val) = self.prvs_instg_agt2 { val.validate()? }
		if let Some(ref val) = self.prvs_instg_agt2_acct { val.validate()? }
		if let Some(ref val) = self.prvs_instg_agt3 { val.validate()? }
		if let Some(ref val) = self.prvs_instg_agt3_acct { val.validate()? }
		if let Some(ref val) = self.instg_agt { val.validate()? }
		if let Some(ref val) = self.instd_agt { val.validate()? }
		if let Some(ref val) = self.intrmy_agt1 { val.validate()? }
		if let Some(ref val) = self.intrmy_agt1_acct { val.validate()? }
		if let Some(ref val) = self.intrmy_agt2 { val.validate()? }
		if let Some(ref val) = self.intrmy_agt2_acct { val.validate()? }
		if let Some(ref val) = self.intrmy_agt3 { val.validate()? }
		if let Some(ref val) = self.intrmy_agt3_acct { val.validate()? }
		if let Some(ref val) = self.ultmt_dbtr { val.validate()? }
		if let Some(ref val) = self.initg_pty { val.validate()? }
		self.dbtr.validate()?;
		if let Some(ref val) = self.dbtr_acct { val.validate()? }
		self.dbtr_agt.validate()?;
		if let Some(ref val) = self.dbtr_agt_acct { val.validate()? }
		self.cdtr_agt.validate()?;
		if let Some(ref val) = self.cdtr_agt_acct { val.validate()? }
		self.cdtr.validate()?;
		if let Some(ref val) = self.cdtr_acct { val.validate()? }
		if let Some(ref val) = self.ultmt_cdtr { val.validate()? }
		if let Some(ref vec) = self.instr_for_cdtr_agt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.instr_for_nxt_agt { for item in vec { item.validate()? } }
		if let Some(ref val) = self.purp { val.validate()? }
		if let Some(ref vec) = self.rgltry_rptg { for item in vec { item.validate()? } }
		if let Some(ref val) = self.tax { val.validate()? }
		if let Some(ref vec) = self.rltd_rmt_inf { for item in vec { item.validate()? } }
		if let Some(ref val) = self.rmt_inf { val.validate()? }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// CreditTransferTransaction65 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CreditTransferTransaction65 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtId") )]
	pub pmt_id: PaymentIdentification6,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtTpInf", skip_serializing_if = "Option::is_none") )]
	pub pmt_tp_inf: Option<PaymentTypeInformation29>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtCond", skip_serializing_if = "Option::is_none") )]
	pub pmt_cond: Option<PaymentCondition2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdExctnDt", skip_serializing_if = "Option::is_none") )]
	pub reqd_exctn_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: AmountType4Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgBr", skip_serializing_if = "Option::is_none") )]
	pub chrg_br: Option<ChargeBearerType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MndtRltdInf", skip_serializing_if = "Option::is_none") )]
	pub mndt_rltd_inf: Option<CreditTransferMandateData1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChqInstr", skip_serializing_if = "Option::is_none") )]
	pub chq_instr: Option<Cheque19>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtDbtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_dbtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt1", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt1: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt2", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt2: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt3", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt3: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgt") )]
	pub cdtr_agt: BranchAndFinancialInstitutionIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub cdtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cdtr") )]
	pub cdtr: PartyIdentification272,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAcct", skip_serializing_if = "Option::is_none") )]
	pub cdtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtCdtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_cdtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrForCdtrAgt", skip_serializing_if = "Option::is_none") )]
	pub instr_for_cdtr_agt: Option<Vec<InstructionForCreditorAgent3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Purp", skip_serializing_if = "Option::is_none") )]
	pub purp: Option<Purpose2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RgltryRptg", skip_serializing_if = "Option::is_none") )]
	pub rgltry_rptg: Option<Vec<RegulatoryReporting3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tax", skip_serializing_if = "Option::is_none") )]
	pub tax: Option<TaxData1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdRmtInf", skip_serializing_if = "Option::is_none") )]
	pub rltd_rmt_inf: Option<Vec<RemittanceLocation8>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RmtInf", skip_serializing_if = "Option::is_none") )]
	pub rmt_inf: Option<RemittanceInformation22>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NclsdFile", skip_serializing_if = "Option::is_none") )]
	pub nclsd_file: Option<Vec<Document15>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl CreditTransferTransaction65 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pmt_id.validate()?;
		if let Some(ref val) = self.pmt_tp_inf { val.validate()? }
		if let Some(ref val) = self.pmt_cond { val.validate()? }
		if let Some(ref val) = self.reqd_exctn_dt { val.validate()? }
		self.amt.validate()?;
		if let Some(ref val) = self.chrg_br { val.validate()? }
		if let Some(ref val) = self.mndt_rltd_inf { val.validate()? }
		if let Some(ref val) = self.chq_instr { val.validate()? }
		if let Some(ref val) = self.ultmt_dbtr { val.validate()? }
		if let Some(ref val) = self.intrmy_agt1 { val.validate()? }
		if let Some(ref val) = self.intrmy_agt2 { val.validate()? }
		if let Some(ref val) = self.intrmy_agt3 { val.validate()? }
		self.cdtr_agt.validate()?;
		if let Some(ref val) = self.cdtr_agt_acct { val.validate()? }
		self.cdtr.validate()?;
		if let Some(ref val) = self.cdtr_acct { val.validate()? }
		if let Some(ref val) = self.ultmt_cdtr { val.validate()? }
		if let Some(ref vec) = self.instr_for_cdtr_agt { for item in vec { item.validate()? } }
		if let Some(ref val) = self.purp { val.validate()? }
		if let Some(ref vec) = self.rgltry_rptg { for item in vec { item.validate()? } }
		if let Some(ref val) = self.tax { val.validate()? }
		if let Some(ref vec) = self.rltd_rmt_inf { for item in vec { item.validate()? } }
		if let Some(ref val) = self.rmt_inf { val.validate()? }
		if let Some(ref vec) = self.nclsd_file { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// CreditTransferTransaction66 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CreditTransferTransaction66 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtId") )]
	pub cdt_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BtchBookg", skip_serializing_if = "Option::is_none") )]
	pub btch_bookg: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtTpInf", skip_serializing_if = "Option::is_none") )]
	pub pmt_tp_inf: Option<PaymentTypeInformation28>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlIntrBkSttlmAmt", skip_serializing_if = "Option::is_none") )]
	pub ttl_intr_bk_sttlm_amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBkSttlmDt", skip_serializing_if = "Option::is_none") )]
	pub intr_bk_sttlm_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmTmIndctn", skip_serializing_if = "Option::is_none") )]
	pub sttlm_tm_indctn: Option<SettlementDateTimeIndication1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstgAgt", skip_serializing_if = "Option::is_none") )]
	pub instg_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstdAgt", skip_serializing_if = "Option::is_none") )]
	pub instd_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt1", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt1: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt1Acct", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt1_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt2", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt2: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt2Acct", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt2_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt3", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt3: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt3Acct", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt3_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgt", skip_serializing_if = "Option::is_none") )]
	pub cdtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub cdtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cdtr") )]
	pub cdtr: BranchAndFinancialInstitutionIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAcct", skip_serializing_if = "Option::is_none") )]
	pub cdtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtCdtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_cdtr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrForCdtrAgt", skip_serializing_if = "Option::is_none") )]
	pub instr_for_cdtr_agt: Option<Vec<InstructionForCreditorAgent3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DrctDbtTxInf") )]
	pub drct_dbt_tx_inf: Vec<DirectDebitTransactionInformation33>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl CreditTransferTransaction66 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.cdt_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "cdt_id is shorter than the minimum length of 1".to_string()));
		}
		if self.cdt_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "cdt_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.pmt_tp_inf { val.validate()? }
		if let Some(ref val) = self.ttl_intr_bk_sttlm_amt { val.validate()? }
		if let Some(ref val) = self.sttlm_tm_indctn { val.validate()? }
		if let Some(ref val) = self.instg_agt { val.validate()? }
		if let Some(ref val) = self.instd_agt { val.validate()? }
		if let Some(ref val) = self.intrmy_agt1 { val.validate()? }
		if let Some(ref val) = self.intrmy_agt1_acct { val.validate()? }
		if let Some(ref val) = self.intrmy_agt2 { val.validate()? }
		if let Some(ref val) = self.intrmy_agt2_acct { val.validate()? }
		if let Some(ref val) = self.intrmy_agt3 { val.validate()? }
		if let Some(ref val) = self.intrmy_agt3_acct { val.validate()? }
		if let Some(ref val) = self.cdtr_agt { val.validate()? }
		if let Some(ref val) = self.cdtr_agt_acct { val.validate()? }
		self.cdtr.validate()?;
		if let Some(ref val) = self.cdtr_acct { val.validate()? }
		if let Some(ref val) = self.ultmt_cdtr { val.validate()? }
		if let Some(ref vec) = self.instr_for_cdtr_agt { for item in vec { item.validate()? } }
		for item in &self.drct_dbt_tx_inf { item.validate()? }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// CreditorEnrolment5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CreditorEnrolment5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Enrlmnt") )]
	pub enrlmnt: CreditorServiceEnrolment1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrTradgNm", skip_serializing_if = "Option::is_none") )]
	pub cdtr_tradg_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cdtr") )]
	pub cdtr: RTPPartyIdentification2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtCdtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_cdtr: Option<RTPPartyIdentification2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MrchntCtgyCd") )]
	pub mrchnt_ctgy_cd: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrLogo", skip_serializing_if = "Option::is_none") )]
	pub cdtr_logo: Option<String>,
}

impl CreditorEnrolment5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.enrlmnt.validate()?;
		if let Some(ref val) = self.cdtr_tradg_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cdtr_tradg_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "cdtr_tradg_nm exceeds the maximum length of 140".to_string()));
			}
		}
		self.cdtr.validate()?;
		if let Some(ref val) = self.ultmt_cdtr { val.validate()? }
		let pattern = Regex::new("[0-9]{4,4}").unwrap();
		if !pattern.is_match(&self.mrchnt_ctgy_cd) {
			return Err(ValidationError::new(1005, "mrchnt_ctgy_cd does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.cdtr_logo {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cdtr_logo is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 10240 {
				return Err(ValidationError::new(1002, "cdtr_logo exceeds the maximum length of 10240".to_string()));
			}
		}
		Ok(())
	}
}


// CreditorEnrolment6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CreditorEnrolment6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Enrlmnt", skip_serializing_if = "Option::is_none") )]
	pub enrlmnt: Option<CreditorServiceEnrolment1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrTradgNm", skip_serializing_if = "Option::is_none") )]
	pub cdtr_tradg_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cdtr") )]
	pub cdtr: RTPPartyIdentification2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtCdtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_cdtr: Option<RTPPartyIdentification2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MrchntCtgyCd", skip_serializing_if = "Option::is_none") )]
	pub mrchnt_ctgy_cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrLogo", skip_serializing_if = "Option::is_none") )]
	pub cdtr_logo: Option<String>,
}

impl CreditorEnrolment6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.enrlmnt { val.validate()? }
		if let Some(ref val) = self.cdtr_tradg_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cdtr_tradg_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "cdtr_tradg_nm exceeds the maximum length of 140".to_string()));
			}
		}
		self.cdtr.validate()?;
		if let Some(ref val) = self.ultmt_cdtr { val.validate()? }
		if let Some(ref val) = self.mrchnt_ctgy_cd {
			let pattern = Regex::new("[0-9]{4,4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "mrchnt_ctgy_cd does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.cdtr_logo {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cdtr_logo is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 10240 {
				return Err(ValidationError::new(1002, "cdtr_logo exceeds the maximum length of 10240".to_string()));
			}
		}
		Ok(())
	}
}


// CreditorEnrolmentAmendment5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CreditorEnrolmentAmendment5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlBizInstr", skip_serializing_if = "Option::is_none") )]
	pub orgnl_biz_instr: Option<OriginalBusinessInstruction1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AmdmntRsn", skip_serializing_if = "Option::is_none") )]
	pub amdmnt_rsn: Option<CreditorEnrolmentAmendmentReason3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amdmnt") )]
	pub amdmnt: CreditorEnrolmentAmendment6,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlEnrlmnt") )]
	pub orgnl_enrlmnt: OriginalEnrolment3Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl CreditorEnrolmentAmendment5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgnl_biz_instr { val.validate()? }
		if let Some(ref val) = self.amdmnt_rsn { val.validate()? }
		self.amdmnt.validate()?;
		self.orgnl_enrlmnt.validate()?;
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// CreditorEnrolmentAmendment6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CreditorEnrolmentAmendment6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrEnrlmnt", skip_serializing_if = "Option::is_none") )]
	pub cdtr_enrlmnt: Option<CreditorEnrolment6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ActvtnData", skip_serializing_if = "Option::is_none") )]
	pub actvtn_data: Option<CreditorInvoice5>,
}

impl CreditorEnrolmentAmendment6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cdtr_enrlmnt { val.validate()? }
		if let Some(ref val) = self.actvtn_data { val.validate()? }
		Ok(())
	}
}


// CreditorEnrolmentAmendmentReason1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CreditorEnrolmentAmendmentReason1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl CreditorEnrolmentAmendmentReason1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// CreditorEnrolmentAmendmentReason3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CreditorEnrolmentAmendmentReason3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Orgtr", skip_serializing_if = "Option::is_none") )]
	pub orgtr: Option<RTPPartyIdentification2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn") )]
	pub rsn: CreditorEnrolmentAmendmentReason1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<Vec<String>>,
}

impl CreditorEnrolmentAmendmentReason3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgtr { val.validate()? }
		self.rsn.validate()?;
		if let Some(ref vec) = self.addtl_inf {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 105 {
					return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 105".to_string()));
				}
			}
		}
		Ok(())
	}
}


// CreditorEnrolmentCancellation3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CreditorEnrolmentCancellation3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlBizInstr", skip_serializing_if = "Option::is_none") )]
	pub orgnl_biz_instr: Option<OriginalBusinessInstruction1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CxlRsn", skip_serializing_if = "Option::is_none") )]
	pub cxl_rsn: Option<CreditorEnrolmentCancellationReason3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlEnrlmnt") )]
	pub orgnl_enrlmnt: OriginalEnrolment3Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl CreditorEnrolmentCancellation3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgnl_biz_instr { val.validate()? }
		if let Some(ref val) = self.cxl_rsn { val.validate()? }
		self.orgnl_enrlmnt.validate()?;
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// CreditorEnrolmentCancellationReason1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CreditorEnrolmentCancellationReason1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl CreditorEnrolmentCancellationReason1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// CreditorEnrolmentCancellationReason3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CreditorEnrolmentCancellationReason3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Orgtr", skip_serializing_if = "Option::is_none") )]
	pub orgtr: Option<RTPPartyIdentification2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn") )]
	pub rsn: CreditorEnrolmentCancellationReason1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<Vec<String>>,
}

impl CreditorEnrolmentCancellationReason3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgtr { val.validate()? }
		self.rsn.validate()?;
		if let Some(ref vec) = self.addtl_inf {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 105 {
					return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 105".to_string()));
				}
			}
		}
		Ok(())
	}
}


// CreditorEnrolmentStatusReason2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CreditorEnrolmentStatusReason2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl CreditorEnrolmentStatusReason2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// CreditorEnrolmentStatusReason3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CreditorEnrolmentStatusReason3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Orgtr", skip_serializing_if = "Option::is_none") )]
	pub orgtr: Option<RTPPartyIdentification2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn") )]
	pub rsn: CreditorEnrolmentStatusReason2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<Vec<String>>,
}

impl CreditorEnrolmentStatusReason3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgtr { val.validate()? }
		self.rsn.validate()?;
		if let Some(ref vec) = self.addtl_inf {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 105 {
					return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 105".to_string()));
				}
			}
		}
		Ok(())
	}
}


// CreditorInvoice5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CreditorInvoice5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "LtdPresntmntInd", skip_serializing_if = "Option::is_none") )]
	pub ltd_presntmnt_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CstmrIdTp", skip_serializing_if = "Option::is_none") )]
	pub cstmr_id_tp: Option<CustomerTypeRequest2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctFrmtTp", skip_serializing_if = "Option::is_none") )]
	pub ctrct_frmt_tp: Option<Vec<DocumentFormat2Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctRefTp", skip_serializing_if = "Option::is_none") )]
	pub ctrct_ref_tp: Option<Vec<DocumentType1Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrInstr", skip_serializing_if = "Option::is_none") )]
	pub cdtr_instr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ActvtnReqDlvryPty", skip_serializing_if = "Option::is_none") )]
	pub actvtn_req_dlvry_pty: Option<RTPPartyIdentification2>,
}

impl CreditorInvoice5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cstmr_id_tp { val.validate()? }
		if let Some(ref vec) = self.ctrct_frmt_tp { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.ctrct_ref_tp { for item in vec { item.validate()? } }
		if let Some(ref val) = self.cdtr_instr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cdtr_instr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 500 {
				return Err(ValidationError::new(1002, "cdtr_instr exceeds the maximum length of 500".to_string()));
			}
		}
		if let Some(ref val) = self.actvtn_req_dlvry_pty { val.validate()? }
		Ok(())
	}
}


// CreditorInvoice6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CreditorInvoice6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "LtdPresntmntInd") )]
	pub ltd_presntmnt_ind: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CstmrIdTp", skip_serializing_if = "Option::is_none") )]
	pub cstmr_id_tp: Option<CustomerTypeRequest2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctFrmtTp", skip_serializing_if = "Option::is_none") )]
	pub ctrct_frmt_tp: Option<Vec<DocumentFormat2Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctRefTp", skip_serializing_if = "Option::is_none") )]
	pub ctrct_ref_tp: Option<Vec<DocumentType1Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrInstr", skip_serializing_if = "Option::is_none") )]
	pub cdtr_instr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ActvtnReqDlvryPty") )]
	pub actvtn_req_dlvry_pty: RTPPartyIdentification2,
}

impl CreditorInvoice6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cstmr_id_tp { val.validate()? }
		if let Some(ref vec) = self.ctrct_frmt_tp { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.ctrct_ref_tp { for item in vec { item.validate()? } }
		if let Some(ref val) = self.cdtr_instr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cdtr_instr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 500 {
				return Err(ValidationError::new(1002, "cdtr_instr exceeds the maximum length of 500".to_string()));
			}
		}
		self.actvtn_req_dlvry_pty.validate()?;
		Ok(())
	}
}


// CreditorReferenceInformation2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CreditorReferenceInformation2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<CreditorReferenceType2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ref", skip_serializing_if = "Option::is_none") )]
	pub ref_attr: Option<String>,
}

impl CreditorReferenceInformation2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.ref_attr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ref_attr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "ref_attr exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// CreditorReferenceInformation3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CreditorReferenceInformation3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<CreditorReferenceType3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ref", skip_serializing_if = "Option::is_none") )]
	pub ref_attr: Option<String>,
}

impl CreditorReferenceInformation3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.ref_attr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ref_attr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "ref_attr exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// CreditorReferenceType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CreditorReferenceType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<DocumentType3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl CreditorReferenceType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// CreditorReferenceType2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CreditorReferenceType2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdOrPrtry") )]
	pub cd_or_prtry: CreditorReferenceType1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issr", skip_serializing_if = "Option::is_none") )]
	pub issr: Option<String>,
}

impl CreditorReferenceType2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.cd_or_prtry.validate()?;
		if let Some(ref val) = self.issr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "issr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "issr exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// CreditorReferenceType2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CreditorReferenceType2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl CreditorReferenceType2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// CreditorReferenceType3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CreditorReferenceType3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdOrPrtry") )]
	pub cd_or_prtry: CreditorReferenceType2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issr", skip_serializing_if = "Option::is_none") )]
	pub issr: Option<String>,
}

impl CreditorReferenceType3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.cd_or_prtry.validate()?;
		if let Some(ref val) = self.issr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "issr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "issr exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// CreditorServiceEnrolment1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CreditorServiceEnrolment1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "EnrlmntStartDt", skip_serializing_if = "Option::is_none") )]
	pub enrlmnt_start_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EnrlmntEndDt", skip_serializing_if = "Option::is_none") )]
	pub enrlmnt_end_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Vsblty", skip_serializing_if = "Option::is_none") )]
	pub vsblty: Option<Visibilty1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SvcActvtnAllwd") )]
	pub svc_actvtn_allwd: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SvcDescLk", skip_serializing_if = "Option::is_none") )]
	pub svc_desc_lk: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrSvcActvtnLk", skip_serializing_if = "Option::is_none") )]
	pub cdtr_svc_actvtn_lk: Option<String>,
}

impl CreditorServiceEnrolment1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.enrlmnt_start_dt { val.validate()? }
		if let Some(ref val) = self.enrlmnt_end_dt { val.validate()? }
		if let Some(ref val) = self.vsblty { val.validate()? }
		if let Some(ref val) = self.svc_desc_lk {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "svc_desc_lk is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 2048 {
				return Err(ValidationError::new(1002, "svc_desc_lk exceeds the maximum length of 2048".to_string()));
			}
		}
		if let Some(ref val) = self.cdtr_svc_actvtn_lk {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cdtr_svc_actvtn_lk is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 2048 {
				return Err(ValidationError::new(1002, "cdtr_svc_actvtn_lk exceeds the maximum length of 2048".to_string()));
			}
		}
		Ok(())
	}
}


// CurrencyAndAmount ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CurrencyAndAmount {
	#[cfg_attr( feature = "derive_serde", serde(rename = "@Ccy") )]
	pub ccy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "$value") )]
	pub value: f64,
}

impl CurrencyAndAmount {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CurrencyCodeAndName1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CurrencyCodeAndName1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd") )]
	pub cd: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm") )]
	pub nm: String,
}

impl CurrencyCodeAndName1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.cd) {
			return Err(ValidationError::new(1005, "cd does not match the required pattern".to_string()));
		}
		if self.nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
		}
		if self.nm.chars().count() > 70 {
			return Err(ValidationError::new(1002, "nm exceeds the maximum length of 70".to_string()));
		}
		Ok(())
	}
}


// CurrencyControlGroupStatus3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CurrencyControlGroupStatus3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlRefs") )]
	pub orgnl_refs: OriginalMessage7,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgPty") )]
	pub rptg_pty: TradeParty6,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegnAgt") )]
	pub regn_agt: BranchAndFinancialInstitutionIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgPrd", skip_serializing_if = "Option::is_none") )]
	pub rptg_prd: Option<Period4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts", skip_serializing_if = "Option::is_none") )]
	pub sts: Option<StatisticalReportingStatus1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsRsn", skip_serializing_if = "Option::is_none") )]
	pub sts_rsn: Option<Vec<ValidationStatusReason3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsDtTm", skip_serializing_if = "Option::is_none") )]
	pub sts_dt_tm: Option<String>,
}

impl CurrencyControlGroupStatus3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.orgnl_refs.validate()?;
		self.rptg_pty.validate()?;
		self.regn_agt.validate()?;
		if let Some(ref val) = self.rptg_prd { val.validate()? }
		if let Some(ref val) = self.sts { val.validate()? }
		if let Some(ref vec) = self.sts_rsn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// CurrencyControlHeader7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CurrencyControlHeader7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm") )]
	pub cre_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfItms") )]
	pub nb_of_itms: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RcvgPty") )]
	pub rcvg_pty: PartyIdentification272,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegnAgt") )]
	pub regn_agt: BranchAndFinancialInstitutionIdentification8,
}

impl CurrencyControlHeader7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		let pattern = Regex::new("[0-9]{1,15}").unwrap();
		if !pattern.is_match(&self.nb_of_itms) {
			return Err(ValidationError::new(1005, "nb_of_itms does not match the required pattern".to_string()));
		}
		self.rcvg_pty.validate()?;
		self.regn_agt.validate()?;
		Ok(())
	}
}


// CurrencyControlHeader8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CurrencyControlHeader8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm") )]
	pub cre_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfItms") )]
	pub nb_of_itms: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitgPty") )]
	pub initg_pty: PartyIdentification272,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FwdgAgt", skip_serializing_if = "Option::is_none") )]
	pub fwdg_agt: Option<BranchAndFinancialInstitutionIdentification8>,
}

impl CurrencyControlHeader8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		let pattern = Regex::new("[0-9]{1,15}").unwrap();
		if !pattern.is_match(&self.nb_of_itms) {
			return Err(ValidationError::new(1005, "nb_of_itms does not match the required pattern".to_string()));
		}
		self.initg_pty.validate()?;
		if let Some(ref val) = self.fwdg_agt { val.validate()? }
		Ok(())
	}
}


// CurrencyControlHeader9 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CurrencyControlHeader9 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm") )]
	pub cre_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfItms") )]
	pub nb_of_itms: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitgPty") )]
	pub initg_pty: Party50Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FwdgAgt", skip_serializing_if = "Option::is_none") )]
	pub fwdg_agt: Option<BranchAndFinancialInstitutionIdentification8>,
}

impl CurrencyControlHeader9 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		let pattern = Regex::new("[0-9]{1,15}").unwrap();
		if !pattern.is_match(&self.nb_of_itms) {
			return Err(ValidationError::new(1005, "nb_of_itms does not match the required pattern".to_string()));
		}
		self.initg_pty.validate()?;
		if let Some(ref val) = self.fwdg_agt { val.validate()? }
		Ok(())
	}
}


// CurrencyControlPackageStatus3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CurrencyControlPackageStatus3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PackgId") )]
	pub packg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts") )]
	pub sts: StatisticalReportingStatus1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsRsn", skip_serializing_if = "Option::is_none") )]
	pub sts_rsn: Option<Vec<ValidationStatusReason3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsDtTm", skip_serializing_if = "Option::is_none") )]
	pub sts_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RcrdSts", skip_serializing_if = "Option::is_none") )]
	pub rcrd_sts: Option<Vec<CurrencyControlRecordStatus3>>,
}

impl CurrencyControlPackageStatus3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.packg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "packg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.packg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "packg_id exceeds the maximum length of 35".to_string()));
		}
		self.sts.validate()?;
		if let Some(ref vec) = self.sts_rsn { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.rcrd_sts { for item in vec { item.validate()? } }
		Ok(())
	}
}


// CurrencyControlRecordStatus3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CurrencyControlRecordStatus3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RcrdId") )]
	pub rcrd_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts") )]
	pub sts: StatisticalReportingStatus1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsRsn", skip_serializing_if = "Option::is_none") )]
	pub sts_rsn: Option<Vec<ValidationStatusReason3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsDtTm", skip_serializing_if = "Option::is_none") )]
	pub sts_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DocId", skip_serializing_if = "Option::is_none") )]
	pub doc_id: Option<DocumentIdentification28>,
}

impl CurrencyControlRecordStatus3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.rcrd_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "rcrd_id is shorter than the minimum length of 1".to_string()));
		}
		if self.rcrd_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "rcrd_id exceeds the maximum length of 35".to_string()));
		}
		self.sts.validate()?;
		if let Some(ref vec) = self.sts_rsn { for item in vec { item.validate()? } }
		if let Some(ref val) = self.doc_id { val.validate()? }
		Ok(())
	}
}


// CurrencyCriteriaDefinition1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CurrencyCriteriaDefinition1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "QryNm", skip_serializing_if = "Option::is_none") )]
	pub qry_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NewCrit", skip_serializing_if = "Option::is_none") )]
	pub new_crit: Option<CurrencyExchangeCriteria2>,
}

impl CurrencyCriteriaDefinition1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.qry_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "qry_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "qry_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.new_crit { val.validate()? }
		Ok(())
	}
}


// CurrencyDesignation1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CurrencyDesignation1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CcyDsgnt", skip_serializing_if = "Option::is_none") )]
	pub ccy_dsgnt: Option<CurrencyDesignation1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Lctn", skip_serializing_if = "Option::is_none") )]
	pub lctn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
}

impl CurrencyDesignation1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ccy_dsgnt { val.validate()? }
		if let Some(ref val) = self.lctn {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "lctn does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 350".to_string()));
			}
		}
		Ok(())
	}
}


// CurrencyDesignation1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum CurrencyDesignation1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ONSH") )]
	CodeONSH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OFFS") )]
	CodeOFFS,
}

impl CurrencyDesignation1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// CurrencyExchange13 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CurrencyExchange13 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SrcCcy") )]
	pub src_ccy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrgtCcy") )]
	pub trgt_ccy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XchgRate") )]
	pub xchg_rate: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnitCcy", skip_serializing_if = "Option::is_none") )]
	pub unit_ccy: Option<String>,
}

impl CurrencyExchange13 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.src_ccy) {
			return Err(ValidationError::new(1005, "src_ccy does not match the required pattern".to_string()));
		}
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.trgt_ccy) {
			return Err(ValidationError::new(1005, "trgt_ccy does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.unit_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "unit_ccy does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// CurrencyExchange20 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CurrencyExchange20 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "XchgRate") )]
	pub xchg_rate: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QtdCcy") )]
	pub qtd_ccy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QtnDt") )]
	pub qtn_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LwLmt", skip_serializing_if = "Option::is_none") )]
	pub lw_lmt: Option<ExchangeRateOrPercentage1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HghLmt", skip_serializing_if = "Option::is_none") )]
	pub hgh_lmt: Option<ExchangeRateOrPercentage1Choice>,
}

impl CurrencyExchange20 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.qtd_ccy) {
			return Err(ValidationError::new(1005, "qtd_ccy does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.lw_lmt { val.validate()? }
		if let Some(ref val) = self.hgh_lmt { val.validate()? }
		Ok(())
	}
}


// CurrencyExchange22 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CurrencyExchange22 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DlvrblCrossCcy", skip_serializing_if = "Option::is_none") )]
	pub dlvrbl_cross_ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XchgRate", skip_serializing_if = "Option::is_none") )]
	pub xchg_rate: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FwdXchgRate", skip_serializing_if = "Option::is_none") )]
	pub fwd_xchg_rate: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XchgRateBsis", skip_serializing_if = "Option::is_none") )]
	pub xchg_rate_bsis: Option<ExchangeRateBasis1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FxgDt", skip_serializing_if = "Option::is_none") )]
	pub fxg_dt: Option<String>,
}

impl CurrencyExchange22 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.dlvrbl_cross_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "dlvrbl_cross_ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.xchg_rate_bsis { val.validate()? }
		Ok(())
	}
}


// CurrencyExchange23 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CurrencyExchange23 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ccy") )]
	pub ccy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XchgRate", skip_serializing_if = "Option::is_none") )]
	pub xchg_rate: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FwdXchgRate", skip_serializing_if = "Option::is_none") )]
	pub fwd_xchg_rate: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XchgRateBsis", skip_serializing_if = "Option::is_none") )]
	pub xchg_rate_bsis: Option<ExchangeRateBasis1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FxgDt", skip_serializing_if = "Option::is_none") )]
	pub fxg_dt: Option<String>,
}

impl CurrencyExchange23 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.ccy) {
			return Err(ValidationError::new(1005, "ccy does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.xchg_rate_bsis { val.validate()? }
		Ok(())
	}
}


// CurrencyExchange24 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CurrencyExchange24 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SrcCcy") )]
	pub src_ccy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrgtCcy", skip_serializing_if = "Option::is_none") )]
	pub trgt_ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnitCcy", skip_serializing_if = "Option::is_none") )]
	pub unit_ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XchgRate") )]
	pub xchg_rate: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctId", skip_serializing_if = "Option::is_none") )]
	pub ctrct_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QtnDt", skip_serializing_if = "Option::is_none") )]
	pub qtn_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XchgRateBase", skip_serializing_if = "Option::is_none") )]
	pub xchg_rate_base: Option<f64>,
}

impl CurrencyExchange24 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.src_ccy) {
			return Err(ValidationError::new(1005, "src_ccy does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.trgt_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "trgt_ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.unit_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "unit_ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.ctrct_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ctrct_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "ctrct_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.xchg_rate_base {
			if *val < 1.000000 {
				return Err(ValidationError::new(1003, "xchg_rate_base is less than the minimum value of 1.000000".to_string()));
			}
		}
		Ok(())
	}
}


// CurrencyExchange6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CurrencyExchange6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SrcCcy") )]
	pub src_ccy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrgtCcy") )]
	pub trgt_ccy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XchgRate") )]
	pub xchg_rate: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Desc", skip_serializing_if = "Option::is_none") )]
	pub desc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnitCcy", skip_serializing_if = "Option::is_none") )]
	pub unit_ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cmnts", skip_serializing_if = "Option::is_none") )]
	pub cmnts: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QtnDt", skip_serializing_if = "Option::is_none") )]
	pub qtn_dt: Option<String>,
}

impl CurrencyExchange6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.src_ccy) {
			return Err(ValidationError::new(1005, "src_ccy does not match the required pattern".to_string()));
		}
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.trgt_ccy) {
			return Err(ValidationError::new(1005, "trgt_ccy does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.desc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "desc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 40 {
				return Err(ValidationError::new(1002, "desc exceeds the maximum length of 40".to_string()));
			}
		}
		if let Some(ref val) = self.unit_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "unit_ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.cmnts {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cmnts is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "cmnts exceeds the maximum length of 70".to_string()));
			}
		}
		Ok(())
	}
}


// CurrencyExchangeCriteria2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CurrencyExchangeCriteria2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NewQryNm", skip_serializing_if = "Option::is_none") )]
	pub new_qry_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SchCrit") )]
	pub sch_crit: Vec<CurrencyExchangeSearchCriteria1>,
}

impl CurrencyExchangeCriteria2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.new_qry_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "new_qry_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "new_qry_nm exceeds the maximum length of 35".to_string()));
			}
		}
		for item in &self.sch_crit { item.validate()? }
		Ok(())
	}
}


// CurrencyExchangeReport4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CurrencyExchangeReport4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CcyRef") )]
	pub ccy_ref: CurrencySourceTarget1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CcyXchgOrErr") )]
	pub ccy_xchg_or_err: ExchangeRateReportOrError4Choice,
}

impl CurrencyExchangeReport4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.ccy_ref.validate()?;
		self.ccy_xchg_or_err.validate()?;
		Ok(())
	}
}


// CurrencyExchangeSearchCriteria1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CurrencyExchangeSearchCriteria1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SrcCcy") )]
	pub src_ccy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrgtCcy") )]
	pub trgt_ccy: String,
}

impl CurrencyExchangeSearchCriteria1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.src_ccy) {
			return Err(ValidationError::new(1005, "src_ccy does not match the required pattern".to_string()));
		}
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.trgt_ccy) {
			return Err(ValidationError::new(1005, "trgt_ccy does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// CurrencyFactors1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CurrencyFactors1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ccy") )]
	pub ccy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ShrtPosLmt") )]
	pub shrt_pos_lmt: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MinPayInAmt") )]
	pub min_pay_in_amt: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VoltlyMrgn") )]
	pub voltly_mrgn: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rate", skip_serializing_if = "Option::is_none") )]
	pub rate: Option<AgreedRate2>,
}

impl CurrencyFactors1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.ccy) {
			return Err(ValidationError::new(1005, "ccy does not match the required pattern".to_string()));
		}
		if self.shrt_pos_lmt < 0.000000 {
			return Err(ValidationError::new(1003, "shrt_pos_lmt is less than the minimum value of 0.000000".to_string()));
		}
		if self.min_pay_in_amt < 0.000000 {
			return Err(ValidationError::new(1003, "min_pay_in_amt is less than the minimum value of 0.000000".to_string()));
		}
		if let Some(ref val) = self.rate { val.validate()? }
		Ok(())
	}
}


// CurrencyQueryDefinition3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CurrencyQueryDefinition3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "QryTp", skip_serializing_if = "Option::is_none") )]
	pub qry_tp: Option<QueryType2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CcyCrit", skip_serializing_if = "Option::is_none") )]
	pub ccy_crit: Option<CurrencyCriteriaDefinition1Choice>,
}

impl CurrencyQueryDefinition3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.qry_tp { val.validate()? }
		if let Some(ref val) = self.ccy_crit { val.validate()? }
		Ok(())
	}
}


// CurrencyReference3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CurrencyReference3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrgtCcy") )]
	pub trgt_ccy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SrcCcy") )]
	pub src_ccy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XchgRateInf", skip_serializing_if = "Option::is_none") )]
	pub xchg_rate_inf: Option<Vec<ExchangeRateInformation1>>,
}

impl CurrencyReference3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.trgt_ccy) {
			return Err(ValidationError::new(1005, "trgt_ccy does not match the required pattern".to_string()));
		}
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.src_ccy) {
			return Err(ValidationError::new(1005, "src_ccy does not match the required pattern".to_string()));
		}
		if let Some(ref vec) = self.xchg_rate_inf { for item in vec { item.validate()? } }
		Ok(())
	}
}


// CurrencySourceTarget1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CurrencySourceTarget1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SrcCcy") )]
	pub src_ccy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrgtCcy") )]
	pub trgt_ccy: String,
}

impl CurrencySourceTarget1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.src_ccy) {
			return Err(ValidationError::new(1005, "src_ccy does not match the required pattern".to_string()));
		}
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.trgt_ccy) {
			return Err(ValidationError::new(1005, "trgt_ccy does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// CurrentAndDefaultReservation6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CurrentAndDefaultReservation6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CurRsvatn", skip_serializing_if = "Option::is_none") )]
	pub cur_rsvatn: Option<Vec<ReservationReport8>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DfltRsvatn", skip_serializing_if = "Option::is_none") )]
	pub dflt_rsvatn: Option<Vec<ReservationReport8>>,
}

impl CurrentAndDefaultReservation6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.cur_rsvatn { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.dflt_rsvatn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// CurrentOrDefaultReservation4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CurrentOrDefaultReservation4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cur", skip_serializing_if = "Option::is_none") )]
	pub cur: Option<ReservationIdentification4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dflt", skip_serializing_if = "Option::is_none") )]
	pub dflt: Option<ReservationIdentification4>,
}

impl CurrentOrDefaultReservation4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cur { val.validate()? }
		if let Some(ref val) = self.dflt { val.validate()? }
		Ok(())
	}
}


// CustomBasket4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CustomBasket4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Strr", skip_serializing_if = "Option::is_none") )]
	pub strr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cnsttnts", skip_serializing_if = "Option::is_none") )]
	pub cnsttnts: Option<Vec<BasketConstituents3>>,
}

impl CustomBasket4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.strr {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "strr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 52 {
				return Err(ValidationError::new(1002, "id exceeds the maximum length of 52".to_string()));
			}
		}
		if let Some(ref vec) = self.cnsttnts { for item in vec { item.validate()? } }
		Ok(())
	}
}


// CustomerAccount4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CustomerAccount4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<AccountIdentification4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts", skip_serializing_if = "Option::is_none") )]
	pub sts: Option<AccountStatus3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<CashAccountType2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ccy") )]
	pub ccy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MnthlyPmtVal", skip_serializing_if = "Option::is_none") )]
	pub mnthly_pmt_val: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MnthlyRcvdVal", skip_serializing_if = "Option::is_none") )]
	pub mnthly_rcvd_val: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MnthlyTxNb", skip_serializing_if = "Option::is_none") )]
	pub mnthly_tx_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AvrgBal", skip_serializing_if = "Option::is_none") )]
	pub avrg_bal: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctPurp", skip_serializing_if = "Option::is_none") )]
	pub acct_purp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FlrNtfctnAmt", skip_serializing_if = "Option::is_none") )]
	pub flr_ntfctn_amt: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClngNtfctnAmt", skip_serializing_if = "Option::is_none") )]
	pub clng_ntfctn_amt: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StmtFrqcyAndFrmt", skip_serializing_if = "Option::is_none") )]
	pub stmt_frqcy_and_frmt: Option<Vec<StatementFrequencyAndForm1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClsgDt", skip_serializing_if = "Option::is_none") )]
	pub clsg_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rstrctn", skip_serializing_if = "Option::is_none") )]
	pub rstrctn: Option<Vec<Restriction1>>,
}

impl CustomerAccount4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.id { val.validate()? }
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 70".to_string()));
			}
		}
		if let Some(ref val) = self.sts { val.validate()? }
		if let Some(ref val) = self.tp { val.validate()? }
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.ccy) {
			return Err(ValidationError::new(1005, "ccy does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.mnthly_pmt_val {
			if *val < 0.000000 {
				return Err(ValidationError::new(1003, "mnthly_pmt_val is less than the minimum value of 0.000000".to_string()));
			}
		}
		if let Some(ref val) = self.mnthly_rcvd_val {
			if *val < 0.000000 {
				return Err(ValidationError::new(1003, "mnthly_rcvd_val is less than the minimum value of 0.000000".to_string()));
			}
		}
		if let Some(ref val) = self.mnthly_tx_nb {
			let pattern = Regex::new("[0-9]{1,5}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "mnthly_tx_nb does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.avrg_bal {
			if *val < 0.000000 {
				return Err(ValidationError::new(1003, "avrg_bal is less than the minimum value of 0.000000".to_string()));
			}
		}
		if let Some(ref val) = self.acct_purp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_purp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "acct_purp exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.flr_ntfctn_amt {
			if *val < 0.000000 {
				return Err(ValidationError::new(1003, "flr_ntfctn_amt is less than the minimum value of 0.000000".to_string()));
			}
		}
		if let Some(ref val) = self.clng_ntfctn_amt {
			if *val < 0.000000 {
				return Err(ValidationError::new(1003, "clng_ntfctn_amt is less than the minimum value of 0.000000".to_string()));
			}
		}
		if let Some(ref vec) = self.stmt_frqcy_and_frmt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.rstrctn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// CustomerAccount5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CustomerAccount5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: Vec<AccountIdentification4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts", skip_serializing_if = "Option::is_none") )]
	pub sts: Option<AccountStatus3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<CashAccountType2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ccy") )]
	pub ccy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MnthlyPmtVal", skip_serializing_if = "Option::is_none") )]
	pub mnthly_pmt_val: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MnthlyRcvdVal", skip_serializing_if = "Option::is_none") )]
	pub mnthly_rcvd_val: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MnthlyTxNb", skip_serializing_if = "Option::is_none") )]
	pub mnthly_tx_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AvrgBal", skip_serializing_if = "Option::is_none") )]
	pub avrg_bal: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctPurp", skip_serializing_if = "Option::is_none") )]
	pub acct_purp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FlrNtfctnAmt", skip_serializing_if = "Option::is_none") )]
	pub flr_ntfctn_amt: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClngNtfctnAmt", skip_serializing_if = "Option::is_none") )]
	pub clng_ntfctn_amt: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StmtFrqcyAndFrmt", skip_serializing_if = "Option::is_none") )]
	pub stmt_frqcy_and_frmt: Option<Vec<StatementFrequencyAndForm1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClsgDt", skip_serializing_if = "Option::is_none") )]
	pub clsg_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rstrctn", skip_serializing_if = "Option::is_none") )]
	pub rstrctn: Option<Vec<Restriction1>>,
}

impl CustomerAccount5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		for item in &self.id { item.validate()? }
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 70".to_string()));
			}
		}
		if let Some(ref val) = self.sts { val.validate()? }
		if let Some(ref val) = self.tp { val.validate()? }
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.ccy) {
			return Err(ValidationError::new(1005, "ccy does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.mnthly_pmt_val {
			if *val < 0.000000 {
				return Err(ValidationError::new(1003, "mnthly_pmt_val is less than the minimum value of 0.000000".to_string()));
			}
		}
		if let Some(ref val) = self.mnthly_rcvd_val {
			if *val < 0.000000 {
				return Err(ValidationError::new(1003, "mnthly_rcvd_val is less than the minimum value of 0.000000".to_string()));
			}
		}
		if let Some(ref val) = self.mnthly_tx_nb {
			let pattern = Regex::new("[0-9]{1,5}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "mnthly_tx_nb does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.avrg_bal {
			if *val < 0.000000 {
				return Err(ValidationError::new(1003, "avrg_bal is less than the minimum value of 0.000000".to_string()));
			}
		}
		if let Some(ref val) = self.acct_purp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_purp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "acct_purp exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.flr_ntfctn_amt {
			if *val < 0.000000 {
				return Err(ValidationError::new(1003, "flr_ntfctn_amt is less than the minimum value of 0.000000".to_string()));
			}
		}
		if let Some(ref val) = self.clng_ntfctn_amt {
			if *val < 0.000000 {
				return Err(ValidationError::new(1003, "clng_ntfctn_amt is less than the minimum value of 0.000000".to_string()));
			}
		}
		if let Some(ref vec) = self.stmt_frqcy_and_frmt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.rstrctn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// CustomerAccountModification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CustomerAccountModification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: Vec<AccountIdentification4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<NameModification1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts", skip_serializing_if = "Option::is_none") )]
	pub sts: Option<AccountStatusModification1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<TypeModification1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ccy") )]
	pub ccy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MnthlyPmtVal", skip_serializing_if = "Option::is_none") )]
	pub mnthly_pmt_val: Option<AmountModification1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MnthlyRcvdVal", skip_serializing_if = "Option::is_none") )]
	pub mnthly_rcvd_val: Option<AmountModification1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MnthlyTxNb", skip_serializing_if = "Option::is_none") )]
	pub mnthly_tx_nb: Option<NumberModification1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AvrgBal", skip_serializing_if = "Option::is_none") )]
	pub avrg_bal: Option<AmountModification1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctPurp", skip_serializing_if = "Option::is_none") )]
	pub acct_purp: Option<PurposeModification1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FlrNtfctnAmt", skip_serializing_if = "Option::is_none") )]
	pub flr_ntfctn_amt: Option<AmountModification1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClngNtfctnAmt", skip_serializing_if = "Option::is_none") )]
	pub clng_ntfctn_amt: Option<AmountModification1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StmtFrqcyAndFrmt", skip_serializing_if = "Option::is_none") )]
	pub stmt_frqcy_and_frmt: Option<Vec<StatementFrequencyAndFormModification1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClsgDt", skip_serializing_if = "Option::is_none") )]
	pub clsg_dt: Option<DateModification1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rstrctn", skip_serializing_if = "Option::is_none") )]
	pub rstrctn: Option<Vec<RestrictionModification1>>,
}

impl CustomerAccountModification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		for item in &self.id { item.validate()? }
		if let Some(ref val) = self.nm { val.validate()? }
		if let Some(ref val) = self.sts { val.validate()? }
		if let Some(ref val) = self.tp { val.validate()? }
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.ccy) {
			return Err(ValidationError::new(1005, "ccy does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.mnthly_pmt_val { val.validate()? }
		if let Some(ref val) = self.mnthly_rcvd_val { val.validate()? }
		if let Some(ref val) = self.mnthly_tx_nb { val.validate()? }
		if let Some(ref val) = self.avrg_bal { val.validate()? }
		if let Some(ref val) = self.acct_purp { val.validate()? }
		if let Some(ref val) = self.flr_ntfctn_amt { val.validate()? }
		if let Some(ref val) = self.clng_ntfctn_amt { val.validate()? }
		if let Some(ref vec) = self.stmt_frqcy_and_frmt { for item in vec { item.validate()? } }
		if let Some(ref val) = self.clsg_dt { val.validate()? }
		if let Some(ref vec) = self.rstrctn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// CustomerConductClassification1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CustomerConductClassification1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<ConductClassification1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl CustomerConductClassification1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// CustomerIdentification2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CustomerIdentification2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pty") )]
	pub pty: PartyIdentification272,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AuthrtyReq") )]
	pub authrty_req: Vec<AuthorityInvestigation2>,
}

impl CustomerIdentification2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pty.validate()?;
		for item in &self.authrty_req { item.validate()? }
		Ok(())
	}
}


// CustomerTypeRequest2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CustomerTypeRequest2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Reqd") )]
	pub reqd: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgTp", skip_serializing_if = "Option::is_none") )]
	pub org_tp: Option<OrganisationType2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvtTp", skip_serializing_if = "Option::is_none") )]
	pub prvt_tp: Option<PersonType2>,
}

impl CustomerTypeRequest2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.org_tp { val.validate()? }
		if let Some(ref val) = self.prvt_tp { val.validate()? }
		Ok(())
	}
}


// CutOff1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CutOff1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CutOffUpdId") )]
	pub cut_off_upd_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ccy") )]
	pub ccy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CutOffTm") )]
	pub cut_off_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValDtOffset") )]
	pub val_dt_offset: String,
}

impl CutOff1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.cut_off_upd_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "cut_off_upd_id is shorter than the minimum length of 1".to_string()));
		}
		if self.cut_off_upd_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "cut_off_upd_id exceeds the maximum length of 35".to_string()));
		}
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.ccy) {
			return Err(ValidationError::new(1005, "ccy does not match the required pattern".to_string()));
		}
		let pattern = Regex::new("0|-1|-2").unwrap();
		if !pattern.is_match(&self.val_dt_offset) {
			return Err(ValidationError::new(1005, "val_dt_offset does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// CutOffData2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct CutOffData2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtcptId") )]
	pub ptcpt_id: PartyIdentification242Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NetgCutOffDtls") )]
	pub netg_cut_off_dtls: Vec<NettingCutOff2>,
}

impl CutOffData2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.ptcpt_id.validate()?;
		for item in &self.netg_cut_off_dtls { item.validate()? }
		Ok(())
	}
}


// DataBaseCheck1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DataBaseCheck1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DBChck") )]
	pub db_chck: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
}

impl DataBaseCheck1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		Ok(())
	}
}


// DataFormat2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DataFormat2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Strd", skip_serializing_if = "Option::is_none") )]
	pub strd: Option<GenericIdentification1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ustrd", skip_serializing_if = "Option::is_none") )]
	pub ustrd: Option<String>,
}

impl DataFormat2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.strd { val.validate()? }
		if let Some(ref val) = self.ustrd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ustrd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "ustrd exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// DataModification1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum DataModification1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "INSE") )]
	CodeINSE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UPDT") )]
	CodeUPDT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DELT") )]
	CodeDELT,
}

impl DataModification1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// DataModification2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum DataModification2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "INSE") )]
	CodeINSE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DELT") )]
	CodeDELT,
}

impl DataModification2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// DateAndAmount1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DateAndAmount1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dt") )]
	pub dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveCurrencyAndAmount,
}

impl DateAndAmount1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.amt.validate()?;
		Ok(())
	}
}


// DateAndDateTime1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DateAndDateTime1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dt", skip_serializing_if = "Option::is_none") )]
	pub dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtTm", skip_serializing_if = "Option::is_none") )]
	pub dt_tm: Option<String>,
}

impl DateAndDateTime1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// DateAndDateTime2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DateAndDateTime2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dt", skip_serializing_if = "Option::is_none") )]
	pub dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtTm", skip_serializing_if = "Option::is_none") )]
	pub dt_tm: Option<String>,
}

impl DateAndDateTime2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// DateAndDateTimeChoice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DateAndDateTimeChoice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dt", skip_serializing_if = "Option::is_none") )]
	pub dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtTm", skip_serializing_if = "Option::is_none") )]
	pub dt_tm: Option<String>,
}

impl DateAndDateTimeChoice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// DateAndDateTimeSearch3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DateAndDateTimeSearch3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtTmSch", skip_serializing_if = "Option::is_none") )]
	pub dt_tm_sch: Option<DateTimePeriod1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtSch", skip_serializing_if = "Option::is_none") )]
	pub dt_sch: Option<DatePeriodSearch1Choice>,
}

impl DateAndDateTimeSearch3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.dt_tm_sch { val.validate()? }
		if let Some(ref val) = self.dt_sch { val.validate()? }
		Ok(())
	}
}


// DateAndDateTimeSearch4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DateAndDateTimeSearch4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtTm", skip_serializing_if = "Option::is_none") )]
	pub dt_tm: Option<DateTimeSearch2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dt", skip_serializing_if = "Option::is_none") )]
	pub dt: Option<DatePeriodSearch1Choice>,
}

impl DateAndDateTimeSearch4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.dt_tm { val.validate()? }
		if let Some(ref val) = self.dt { val.validate()? }
		Ok(())
	}
}


// DateAndDateTimeSearch5Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DateAndDateTimeSearch5Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dt", skip_serializing_if = "Option::is_none") )]
	pub dt: Option<DatePeriodSearch1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtTm", skip_serializing_if = "Option::is_none") )]
	pub dt_tm: Option<DateTimeSearch2Choice>,
}

impl DateAndDateTimeSearch5Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.dt { val.validate()? }
		if let Some(ref val) = self.dt_tm { val.validate()? }
		Ok(())
	}
}


// DateAndPeriod2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DateAndPeriod2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dt", skip_serializing_if = "Option::is_none") )]
	pub dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prd", skip_serializing_if = "Option::is_none") )]
	pub prd: Option<Period2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrDt", skip_serializing_if = "Option::is_none") )]
	pub fr_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ToDt", skip_serializing_if = "Option::is_none") )]
	pub to_dt: Option<String>,
}

impl DateAndPeriod2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.prd { val.validate()? }
		Ok(())
	}
}


// DateAndPlaceOfBirth ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DateAndPlaceOfBirth {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BirthDt") )]
	pub birth_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvcOfBirth", skip_serializing_if = "Option::is_none") )]
	pub prvc_of_birth: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CityOfBirth") )]
	pub city_of_birth: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtryOfBirth") )]
	pub ctry_of_birth: String,
}

impl DateAndPlaceOfBirth {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.prvc_of_birth {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prvc_of_birth is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prvc_of_birth exceeds the maximum length of 35".to_string()));
			}
		}
		if self.city_of_birth.chars().count() < 1 {
			return Err(ValidationError::new(1001, "city_of_birth is shorter than the minimum length of 1".to_string()));
		}
		if self.city_of_birth.chars().count() > 35 {
			return Err(ValidationError::new(1002, "city_of_birth exceeds the maximum length of 35".to_string()));
		}
		let pattern = Regex::new("[A-Z]{2,2}").unwrap();
		if !pattern.is_match(&self.ctry_of_birth) {
			return Err(ValidationError::new(1005, "ctry_of_birth does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// DateAndPlaceOfBirth1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DateAndPlaceOfBirth1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BirthDt") )]
	pub birth_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvcOfBirth", skip_serializing_if = "Option::is_none") )]
	pub prvc_of_birth: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CityOfBirth") )]
	pub city_of_birth: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtryOfBirth") )]
	pub ctry_of_birth: String,
}

impl DateAndPlaceOfBirth1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.prvc_of_birth {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prvc_of_birth is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prvc_of_birth exceeds the maximum length of 35".to_string()));
			}
		}
		if self.city_of_birth.chars().count() < 1 {
			return Err(ValidationError::new(1001, "city_of_birth is shorter than the minimum length of 1".to_string()));
		}
		if self.city_of_birth.chars().count() > 35 {
			return Err(ValidationError::new(1002, "city_of_birth exceeds the maximum length of 35".to_string()));
		}
		let pattern = Regex::new("[A-Z]{2,2}").unwrap();
		if !pattern.is_match(&self.ctry_of_birth) {
			return Err(ValidationError::new(1005, "ctry_of_birth does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// DateAndType1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DateAndType1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: DateType2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dt") )]
	pub dt: String,
}

impl DateAndType1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tp.validate()?;
		Ok(())
	}
}


// DateModification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DateModification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModCd", skip_serializing_if = "Option::is_none") )]
	pub mod_cd: Option<Modification1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dt") )]
	pub dt: String,
}

impl DateModification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mod_cd { val.validate()? }
		Ok(())
	}
}


// DateOrBlankQuery2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DateOrBlankQuery2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rg", skip_serializing_if = "Option::is_none") )]
	pub rg: Option<DatePeriod1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NotRptd", skip_serializing_if = "Option::is_none") )]
	pub not_rptd: Option<NotReported1Code>,
}

impl DateOrBlankQuery2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rg { val.validate()? }
		if let Some(ref val) = self.not_rptd { val.validate()? }
		Ok(())
	}
}


// DateOrDateTimePeriod1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DateOrDateTimePeriod1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dt", skip_serializing_if = "Option::is_none") )]
	pub dt: Option<DatePeriod2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtTm", skip_serializing_if = "Option::is_none") )]
	pub dt_tm: Option<DateTimePeriod1>,
}

impl DateOrDateTimePeriod1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.dt { val.validate()? }
		if let Some(ref val) = self.dt_tm { val.validate()? }
		Ok(())
	}
}


// DateOrDateTimePeriodChoice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DateOrDateTimePeriodChoice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dt", skip_serializing_if = "Option::is_none") )]
	pub dt: Option<DatePeriodDetails>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtTm", skip_serializing_if = "Option::is_none") )]
	pub dt_tm: Option<DateTimePeriodDetails>,
}

impl DateOrDateTimePeriodChoice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.dt { val.validate()? }
		if let Some(ref val) = self.dt_tm { val.validate()? }
		Ok(())
	}
}


// DatePeriod1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DatePeriod1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrDt", skip_serializing_if = "Option::is_none") )]
	pub fr_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ToDt") )]
	pub to_dt: String,
}

impl DatePeriod1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// DatePeriod2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DatePeriod2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrDt") )]
	pub fr_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ToDt") )]
	pub to_dt: String,
}

impl DatePeriod2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// DatePeriod2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DatePeriod2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrDt", skip_serializing_if = "Option::is_none") )]
	pub fr_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ToDt", skip_serializing_if = "Option::is_none") )]
	pub to_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrToDt", skip_serializing_if = "Option::is_none") )]
	pub fr_to_dt: Option<DatePeriod2>,
}

impl DatePeriod2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.fr_to_dt { val.validate()? }
		Ok(())
	}
}


// DatePeriod3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DatePeriod3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrDt") )]
	pub fr_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ToDt", skip_serializing_if = "Option::is_none") )]
	pub to_dt: Option<String>,
}

impl DatePeriod3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// DatePeriod3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DatePeriod3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrDt", skip_serializing_if = "Option::is_none") )]
	pub fr_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ToDt", skip_serializing_if = "Option::is_none") )]
	pub to_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrToDt", skip_serializing_if = "Option::is_none") )]
	pub fr_to_dt: Option<DatePeriod2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dt", skip_serializing_if = "Option::is_none") )]
	pub dt: Option<String>,
}

impl DatePeriod3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.fr_to_dt { val.validate()? }
		Ok(())
	}
}


// DatePeriod4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DatePeriod4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrDt", skip_serializing_if = "Option::is_none") )]
	pub fr_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ToDt", skip_serializing_if = "Option::is_none") )]
	pub to_dt: Option<String>,
}

impl DatePeriod4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// DatePeriod5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DatePeriod5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CurValDt") )]
	pub cur_val_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdValDt") )]
	pub reqd_val_dt: String,
}

impl DatePeriod5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// DatePeriodDetails ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DatePeriodDetails {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrDt") )]
	pub fr_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ToDt") )]
	pub to_dt: String,
}

impl DatePeriodDetails {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// DatePeriodSearch1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DatePeriodSearch1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrDt", skip_serializing_if = "Option::is_none") )]
	pub fr_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ToDt", skip_serializing_if = "Option::is_none") )]
	pub to_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrToDt", skip_serializing_if = "Option::is_none") )]
	pub fr_to_dt: Option<DatePeriod2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EQDt", skip_serializing_if = "Option::is_none") )]
	pub eq_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NEQDt", skip_serializing_if = "Option::is_none") )]
	pub neq_dt: Option<String>,
}

impl DatePeriodSearch1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.fr_to_dt { val.validate()? }
		Ok(())
	}
}


// DateTimeOrBlankQuery1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DateTimeOrBlankQuery1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rg", skip_serializing_if = "Option::is_none") )]
	pub rg: Option<DateTimePeriod1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NotRptd", skip_serializing_if = "Option::is_none") )]
	pub not_rptd: Option<NotReported1Code>,
}

impl DateTimeOrBlankQuery1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rg { val.validate()? }
		if let Some(ref val) = self.not_rptd { val.validate()? }
		Ok(())
	}
}


// DateTimePeriod1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DateTimePeriod1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrDtTm") )]
	pub fr_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ToDtTm") )]
	pub to_dt_tm: String,
}

impl DateTimePeriod1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// DateTimePeriod1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DateTimePeriod1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrDtTm", skip_serializing_if = "Option::is_none") )]
	pub fr_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ToDtTm", skip_serializing_if = "Option::is_none") )]
	pub to_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtTmRg", skip_serializing_if = "Option::is_none") )]
	pub dt_tm_rg: Option<DateTimePeriod1>,
}

impl DateTimePeriod1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.dt_tm_rg { val.validate()? }
		Ok(())
	}
}


// DateTimePeriod2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DateTimePeriod2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrDtTm") )]
	pub fr_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ToDtTm", skip_serializing_if = "Option::is_none") )]
	pub to_dt_tm: Option<String>,
}

impl DateTimePeriod2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// DateTimePeriodDetails ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DateTimePeriodDetails {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrDtTm") )]
	pub fr_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ToDtTm") )]
	pub to_dt_tm: String,
}

impl DateTimePeriodDetails {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// DateTimeSearch2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DateTimeSearch2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrDtTm", skip_serializing_if = "Option::is_none") )]
	pub fr_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ToDtTm", skip_serializing_if = "Option::is_none") )]
	pub to_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrToDtTm", skip_serializing_if = "Option::is_none") )]
	pub fr_to_dt_tm: Option<DateTimePeriod1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EQDtTm", skip_serializing_if = "Option::is_none") )]
	pub eq_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NEQDtTm", skip_serializing_if = "Option::is_none") )]
	pub neq_dt_tm: Option<String>,
}

impl DateTimeSearch2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.fr_to_dt_tm { val.validate()? }
		Ok(())
	}
}


// DateType2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DateType2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl DateType2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// DeMinimus1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DeMinimus1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DeMnmsAplbl", skip_serializing_if = "Option::is_none") )]
	pub de_mnms_aplbl: Option<DeMinimusApplicable1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DeMnmsNotAplbl", skip_serializing_if = "Option::is_none") )]
	pub de_mnms_not_aplbl: Option<DeMinimusNotApplicable1>,
}

impl DeMinimus1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.de_mnms_aplbl { val.validate()? }
		if let Some(ref val) = self.de_mnms_not_aplbl { val.validate()? }
		Ok(())
	}
}


// DeMinimusApplicable1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DeMinimusApplicable1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NewIssePrmssn") )]
	pub new_isse_prmssn: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pctg", skip_serializing_if = "Option::is_none") )]
	pub pctg: Option<f64>,
}

impl DeMinimusApplicable1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// DeMinimusNotApplicable1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DeMinimusNotApplicable1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RstrctdPrsnRsn") )]
	pub rstrctd_prsn_rsn: String,
}

impl DeMinimusNotApplicable1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.rstrctd_prsn_rsn.chars().count() < 1 {
			return Err(ValidationError::new(1001, "rstrctd_prsn_rsn is shorter than the minimum length of 1".to_string()));
		}
		if self.rstrctd_prsn_rsn.chars().count() > 350 {
			return Err(ValidationError::new(1002, "rstrctd_prsn_rsn exceeds the maximum length of 350".to_string()));
		}
		Ok(())
	}
}


// DebitAuthorisation2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DebitAuthorisation2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CxlRsn") )]
	pub cxl_rsn: CancellationReason33Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AmtToDbt", skip_serializing_if = "Option::is_none") )]
	pub amt_to_dbt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValDtToDbt", skip_serializing_if = "Option::is_none") )]
	pub val_dt_to_dbt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlCxlRsnInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_cxl_rsn_inf: Option<Vec<String>>,
}

impl DebitAuthorisation2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.cxl_rsn.validate()?;
		if let Some(ref val) = self.amt_to_dbt { val.validate()? }
		if let Some(ref vec) = self.addtl_cxl_rsn_inf {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "addtl_cxl_rsn_inf is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 105 {
					return Err(ValidationError::new(1002, "addtl_cxl_rsn_inf exceeds the maximum length of 105".to_string()));
				}
			}
		}
		Ok(())
	}
}


// DebitAuthorisation3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DebitAuthorisation3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CxlRsn") )]
	pub cxl_rsn: CancellationReason33Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AmtToDbt", skip_serializing_if = "Option::is_none") )]
	pub amt_to_dbt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Acct", skip_serializing_if = "Option::is_none") )]
	pub acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValDtToDbt", skip_serializing_if = "Option::is_none") )]
	pub val_dt_to_dbt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlCxlRsnInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_cxl_rsn_inf: Option<Vec<String>>,
}

impl DebitAuthorisation3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.cxl_rsn.validate()?;
		if let Some(ref val) = self.amt_to_dbt { val.validate()? }
		if let Some(ref val) = self.acct { val.validate()? }
		if let Some(ref vec) = self.addtl_cxl_rsn_inf {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "addtl_cxl_rsn_inf is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 140 {
					return Err(ValidationError::new(1002, "addtl_cxl_rsn_inf exceeds the maximum length of 140".to_string()));
				}
			}
		}
		Ok(())
	}
}


// DebitAuthorisationConfirmation2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DebitAuthorisationConfirmation2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtAuthstn") )]
	pub dbt_authstn: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AmtToDbt", skip_serializing_if = "Option::is_none") )]
	pub amt_to_dbt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValDtToDbt", skip_serializing_if = "Option::is_none") )]
	pub val_dt_to_dbt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<String>,
}

impl DebitAuthorisationConfirmation2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.amt_to_dbt { val.validate()? }
		if let Some(ref val) = self.rsn {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rsn is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "rsn exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// DebitAuthorisationConfirmation3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DebitAuthorisationConfirmation3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtAuthstn") )]
	pub dbt_authstn: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AmtToDbt", skip_serializing_if = "Option::is_none") )]
	pub amt_to_dbt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Acct", skip_serializing_if = "Option::is_none") )]
	pub acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValDtToDbt", skip_serializing_if = "Option::is_none") )]
	pub val_dt_to_dbt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CmonTxId", skip_serializing_if = "Option::is_none") )]
	pub cmon_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<String>,
}

impl DebitAuthorisationConfirmation3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.amt_to_dbt { val.validate()? }
		if let Some(ref val) = self.acct { val.validate()? }
		if let Some(ref val) = self.cmon_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cmon_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 52 {
				return Err(ValidationError::new(1002, "cmon_tx_id exceeds the maximum length of 52".to_string()));
			}
		}
		if let Some(ref val) = self.rsn {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rsn is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "rsn exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// Debt5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Debt5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtCcy", skip_serializing_if = "Option::is_none") )]
	pub pmt_ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FaceAmt", skip_serializing_if = "Option::is_none") )]
	pub face_amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtFrqcy", skip_serializing_if = "Option::is_none") )]
	pub pmt_frqcy: Option<Frequency35Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstFxgDt", skip_serializing_if = "Option::is_none") )]
	pub intrst_fxg_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtdDt", skip_serializing_if = "Option::is_none") )]
	pub dtd_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrstPmtDt", skip_serializing_if = "Option::is_none") )]
	pub frst_pmt_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MtrtyDt", skip_serializing_if = "Option::is_none") )]
	pub mtrty_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NxtCpnDt", skip_serializing_if = "Option::is_none") )]
	pub nxt_cpn_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PutblDt", skip_serializing_if = "Option::is_none") )]
	pub putbl_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NxtCllblDt", skip_serializing_if = "Option::is_none") )]
	pub nxt_cllbl_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NxtFctrDt", skip_serializing_if = "Option::is_none") )]
	pub nxt_fctr_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XprtnDt", skip_serializing_if = "Option::is_none") )]
	pub xprtn_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtDrctnInd", skip_serializing_if = "Option::is_none") )]
	pub pmt_drctn_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstRate", skip_serializing_if = "Option::is_none") )]
	pub intrst_rate: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NxtIntrstRate", skip_serializing_if = "Option::is_none") )]
	pub nxt_intrst_rate: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OddCpnInd", skip_serializing_if = "Option::is_none") )]
	pub odd_cpn_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CllblInd", skip_serializing_if = "Option::is_none") )]
	pub cllbl_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CPPrgm", skip_serializing_if = "Option::is_none") )]
	pub cp_prgm: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CPRegnTp", skip_serializing_if = "Option::is_none") )]
	pub cp_regn_tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstAcrlDt", skip_serializing_if = "Option::is_none") )]
	pub intrst_acrl_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PutblInd", skip_serializing_if = "Option::is_none") )]
	pub putbl_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PreFnddInd", skip_serializing_if = "Option::is_none") )]
	pub pre_fndd_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EscrwdInd", skip_serializing_if = "Option::is_none") )]
	pub escrwd_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PerptlInd", skip_serializing_if = "Option::is_none") )]
	pub perptl_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubrdntdInd", skip_serializing_if = "Option::is_none") )]
	pub subrdntd_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XtndblInd", skip_serializing_if = "Option::is_none") )]
	pub xtndbl_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XtndblPrd", skip_serializing_if = "Option::is_none") )]
	pub xtndbl_prd: Option<DateTimePeriod1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VarblRateInd", skip_serializing_if = "Option::is_none") )]
	pub varbl_rate_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OverAlltmtAmt", skip_serializing_if = "Option::is_none") )]
	pub over_alltmt_amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OverAlltmtRate", skip_serializing_if = "Option::is_none") )]
	pub over_alltmt_rate: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AmtsblInd", skip_serializing_if = "Option::is_none") )]
	pub amtsbl_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstClctnMtd", skip_serializing_if = "Option::is_none") )]
	pub intrst_clctn_mtd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CptlsdIntrst", skip_serializing_if = "Option::is_none") )]
	pub cptlsd_intrst: Option<DistributionPolicy2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ActlDnmtnAmt", skip_serializing_if = "Option::is_none") )]
	pub actl_dnmtn_amt: Option<Vec<ActiveCurrencyAndAmount>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CurFctr", skip_serializing_if = "Option::is_none") )]
	pub cur_fctr: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NxtFctr", skip_serializing_if = "Option::is_none") )]
	pub nxt_fctr: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsFctr", skip_serializing_if = "Option::is_none") )]
	pub prvs_fctr: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pcs", skip_serializing_if = "Option::is_none") )]
	pub pcs: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PlsMax", skip_serializing_if = "Option::is_none") )]
	pub pls_max: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PlsPerMln", skip_serializing_if = "Option::is_none") )]
	pub pls_per_mln: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PlsPerLot", skip_serializing_if = "Option::is_none") )]
	pub pls_per_lot: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PlsPerTrad", skip_serializing_if = "Option::is_none") )]
	pub pls_per_trad: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CstPrePmtPnltyInd", skip_serializing_if = "Option::is_none") )]
	pub cst_pre_pmt_pnlty_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LotId", skip_serializing_if = "Option::is_none") )]
	pub lot_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CstPrePmtYld", skip_serializing_if = "Option::is_none") )]
	pub cst_pre_pmt_yld: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WghtdAvrgCpn", skip_serializing_if = "Option::is_none") )]
	pub wghtd_avrg_cpn: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WghtdAvrgLife", skip_serializing_if = "Option::is_none") )]
	pub wghtd_avrg_life: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WghtdAvrgLn", skip_serializing_if = "Option::is_none") )]
	pub wghtd_avrg_ln: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WghtdAvrgMtrty", skip_serializing_if = "Option::is_none") )]
	pub wghtd_avrg_mtrty: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InsrdInd", skip_serializing_if = "Option::is_none") )]
	pub insrd_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BkQlfdInd", skip_serializing_if = "Option::is_none") )]
	pub bk_qlfd_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "YldClctn", skip_serializing_if = "Option::is_none") )]
	pub yld_clctn: Option<Vec<YieldCalculation6>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstTp", skip_serializing_if = "Option::is_none") )]
	pub intrst_tp: Option<InterestType3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrmStrTp", skip_serializing_if = "Option::is_none") )]
	pub instrm_str_tp: Option<InstrumentSubStructureType2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GblTp", skip_serializing_if = "Option::is_none") )]
	pub gbl_tp: Option<GlobalNote2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PotntlEuroSysElgblty", skip_serializing_if = "Option::is_none") )]
	pub potntl_euro_sys_elgblty: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Geogcs", skip_serializing_if = "Option::is_none") )]
	pub geogcs: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "YldRg", skip_serializing_if = "Option::is_none") )]
	pub yld_rg: Option<AmountOrPercentageRange1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CpnRg", skip_serializing_if = "Option::is_none") )]
	pub cpn_rg: Option<AmountOrPercentageRange1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Purp", skip_serializing_if = "Option::is_none") )]
	pub purp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AltrntvMinTaxInd", skip_serializing_if = "Option::is_none") )]
	pub altrntv_min_tax_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AutoRinvstmt", skip_serializing_if = "Option::is_none") )]
	pub auto_rinvstmt: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Hrcut", skip_serializing_if = "Option::is_none") )]
	pub hrcut: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxConds", skip_serializing_if = "Option::is_none") )]
	pub tx_conds: Option<TradeTransactionCondition7Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LookBck", skip_serializing_if = "Option::is_none") )]
	pub look_bck: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MaxSbstitn", skip_serializing_if = "Option::is_none") )]
	pub max_sbstitn: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MinIncrmt", skip_serializing_if = "Option::is_none") )]
	pub min_incrmt: Option<FinancialInstrumentQuantity1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MinQty", skip_serializing_if = "Option::is_none") )]
	pub min_qty: Option<FinancialInstrumentQuantity1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pdctn", skip_serializing_if = "Option::is_none") )]
	pub pdctn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RstrctdInd", skip_serializing_if = "Option::is_none") )]
	pub rstrctd_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PricFrqcy", skip_serializing_if = "Option::is_none") )]
	pub pric_frqcy: Option<Frequency35Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sctr", skip_serializing_if = "Option::is_none") )]
	pub sctr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SbstitnFrqcy", skip_serializing_if = "Option::is_none") )]
	pub sbstitn_frqcy: Option<Frequency35Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SbstitnLft", skip_serializing_if = "Option::is_none") )]
	pub sbstitn_lft: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WhlPoolInd", skip_serializing_if = "Option::is_none") )]
	pub whl_pool_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PricSrc", skip_serializing_if = "Option::is_none") )]
	pub pric_src: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PricRg", skip_serializing_if = "Option::is_none") )]
	pub pric_rg: Option<AmountOrPercentageRange1>,
}

impl Debt5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.pmt_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "pmt_ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.face_amt { val.validate()? }
		if let Some(ref val) = self.pmt_frqcy { val.validate()? }
		if let Some(ref val) = self.cp_regn_tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cp_regn_tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "cp_regn_tp exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.xtndbl_prd { val.validate()? }
		if let Some(ref val) = self.over_alltmt_amt { val.validate()? }
		if let Some(ref val) = self.intrst_clctn_mtd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "intrst_clctn_mtd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "intrst_clctn_mtd exceeds the maximum length of 70".to_string()));
			}
		}
		if let Some(ref val) = self.cptlsd_intrst { val.validate()? }
		if let Some(ref vec) = self.actl_dnmtn_amt { for item in vec { item.validate()? } }
		if let Some(ref val) = self.lot_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "lot_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "lot_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref vec) = self.yld_clctn { for item in vec { item.validate()? } }
		if let Some(ref val) = self.intrst_tp { val.validate()? }
		if let Some(ref val) = self.instrm_str_tp { val.validate()? }
		if let Some(ref val) = self.gbl_tp { val.validate()? }
		if let Some(ref val) = self.geogcs {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "geogcs is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "geogcs exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.yld_rg { val.validate()? }
		if let Some(ref val) = self.cpn_rg { val.validate()? }
		if let Some(ref val) = self.purp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "purp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 256 {
				return Err(ValidationError::new(1002, "purp exceeds the maximum length of 256".to_string()));
			}
		}
		if let Some(ref val) = self.tx_conds { val.validate()? }
		if let Some(ref val) = self.min_incrmt { val.validate()? }
		if let Some(ref val) = self.min_qty { val.validate()? }
		if let Some(ref val) = self.pdctn {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pdctn is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "pdctn exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.pric_frqcy { val.validate()? }
		if let Some(ref val) = self.sctr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "sctr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "sctr exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.sbstitn_frqcy { val.validate()? }
		if let Some(ref val) = self.pric_src {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pric_src is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "pric_src exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.pric_rg { val.validate()? }
		Ok(())
	}
}


// DebtInstrument2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DebtInstrument2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlIssdNmnlAmt") )]
	pub ttl_issd_nmnl_amt: ActiveOrHistoricCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MtrtyDt", skip_serializing_if = "Option::is_none") )]
	pub mtrty_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NmnlValPerUnit") )]
	pub nmnl_val_per_unit: ActiveOrHistoricCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstRate") )]
	pub intrst_rate: InterestRate6Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DebtSnrty", skip_serializing_if = "Option::is_none") )]
	pub debt_snrty: Option<DebtInstrumentSeniorityType1Code>,
}

impl DebtInstrument2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.ttl_issd_nmnl_amt.validate()?;
		self.nmnl_val_per_unit.validate()?;
		self.intrst_rate.validate()?;
		if let Some(ref val) = self.debt_snrty { val.validate()? }
		Ok(())
	}
}


// DebtInstrument4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DebtInstrument4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MtrtyDt") )]
	pub mtrty_dt: String,
}

impl DebtInstrument4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// DebtInstrument5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DebtInstrument5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: BondType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IssncDt") )]
	pub issnc_dt: String,
}

impl DebtInstrument5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tp.validate()?;
		Ok(())
	}
}


// DebtInstrumentSeniorityType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum DebtInstrumentSeniorityType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "SBOD") )]
	CodeSBOD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SNDB") )]
	CodeSNDB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MZZD") )]
	CodeMZZD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "JUND") )]
	CodeJUND,
}

impl DebtInstrumentSeniorityType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// DebtInstrumentSeniorityType2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum DebtInstrumentSeniorityType2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "SBOD") )]
	CodeSBOD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SNDB") )]
	CodeSNDB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
}

impl DebtInstrumentSeniorityType2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// DebtorActivation5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DebtorActivation5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrActvtnId", skip_serializing_if = "Option::is_none") )]
	pub dbtr_actvtn_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DispNm", skip_serializing_if = "Option::is_none") )]
	pub disp_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtDbtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_dbtr: Option<RTPPartyIdentification2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dbtr") )]
	pub dbtr: RTPPartyIdentification2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrSolPrvdr") )]
	pub dbtr_sol_prvdr: RTPPartyIdentification2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CstmrId", skip_serializing_if = "Option::is_none") )]
	pub cstmr_id: Option<Vec<Party53Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctFrmtTp", skip_serializing_if = "Option::is_none") )]
	pub ctrct_frmt_tp: Option<Vec<DocumentFormat2Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctRef", skip_serializing_if = "Option::is_none") )]
	pub ctrct_ref: Option<Vec<ContractReference1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cdtr") )]
	pub cdtr: RTPPartyIdentification2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtCdtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_cdtr: Option<RTPPartyIdentification2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ActvtnReqDlvryPty", skip_serializing_if = "Option::is_none") )]
	pub actvtn_req_dlvry_pty: Option<RTPPartyIdentification2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StartDt", skip_serializing_if = "Option::is_none") )]
	pub start_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndDt", skip_serializing_if = "Option::is_none") )]
	pub end_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DdctdActvtnCd", skip_serializing_if = "Option::is_none") )]
	pub ddctd_actvtn_cd: Option<String>,
}

impl DebtorActivation5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.dbtr_actvtn_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "dbtr_actvtn_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "dbtr_actvtn_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.disp_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "disp_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "disp_nm exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.ultmt_dbtr { val.validate()? }
		self.dbtr.validate()?;
		self.dbtr_sol_prvdr.validate()?;
		if let Some(ref vec) = self.cstmr_id { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.ctrct_frmt_tp { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.ctrct_ref { for item in vec { item.validate()? } }
		self.cdtr.validate()?;
		if let Some(ref val) = self.ultmt_cdtr { val.validate()? }
		if let Some(ref val) = self.actvtn_req_dlvry_pty { val.validate()? }
		if let Some(ref val) = self.start_dt { val.validate()? }
		if let Some(ref val) = self.end_dt { val.validate()? }
		if let Some(ref val) = self.ddctd_actvtn_cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ddctd_actvtn_cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "ddctd_actvtn_cd exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// DebtorActivation6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DebtorActivation6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrActvtnId", skip_serializing_if = "Option::is_none") )]
	pub dbtr_actvtn_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DispNm", skip_serializing_if = "Option::is_none") )]
	pub disp_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtDbtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_dbtr: Option<RTPPartyIdentification2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dbtr", skip_serializing_if = "Option::is_none") )]
	pub dbtr: Option<RTPPartyIdentification2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrSolPrvdr", skip_serializing_if = "Option::is_none") )]
	pub dbtr_sol_prvdr: Option<RTPPartyIdentification2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CstmrId", skip_serializing_if = "Option::is_none") )]
	pub cstmr_id: Option<Vec<Party53Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctFrmtTp", skip_serializing_if = "Option::is_none") )]
	pub ctrct_frmt_tp: Option<Vec<DocumentFormat2Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctRef", skip_serializing_if = "Option::is_none") )]
	pub ctrct_ref: Option<Vec<ContractReference1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cdtr", skip_serializing_if = "Option::is_none") )]
	pub cdtr: Option<RTPPartyIdentification2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtCdtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_cdtr: Option<RTPPartyIdentification2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ActvtnReqDlvryPty", skip_serializing_if = "Option::is_none") )]
	pub actvtn_req_dlvry_pty: Option<RTPPartyIdentification2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StartDt", skip_serializing_if = "Option::is_none") )]
	pub start_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndDt", skip_serializing_if = "Option::is_none") )]
	pub end_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DdctdActvtnCd", skip_serializing_if = "Option::is_none") )]
	pub ddctd_actvtn_cd: Option<String>,
}

impl DebtorActivation6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.dbtr_actvtn_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "dbtr_actvtn_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "dbtr_actvtn_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.disp_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "disp_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "disp_nm exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.ultmt_dbtr { val.validate()? }
		if let Some(ref val) = self.dbtr { val.validate()? }
		if let Some(ref val) = self.dbtr_sol_prvdr { val.validate()? }
		if let Some(ref vec) = self.cstmr_id { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.ctrct_frmt_tp { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.ctrct_ref { for item in vec { item.validate()? } }
		if let Some(ref val) = self.cdtr { val.validate()? }
		if let Some(ref val) = self.ultmt_cdtr { val.validate()? }
		if let Some(ref val) = self.actvtn_req_dlvry_pty { val.validate()? }
		if let Some(ref val) = self.start_dt { val.validate()? }
		if let Some(ref val) = self.end_dt { val.validate()? }
		if let Some(ref val) = self.ddctd_actvtn_cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ddctd_actvtn_cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "ddctd_actvtn_cd exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// DebtorActivationAmendment5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DebtorActivationAmendment5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlBizInstr", skip_serializing_if = "Option::is_none") )]
	pub orgnl_biz_instr: Option<OriginalBusinessInstruction1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AmdmntRsn", skip_serializing_if = "Option::is_none") )]
	pub amdmnt_rsn: Option<DebtorActivationAmendmentReason3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amdmnt") )]
	pub amdmnt: DebtorActivationAmendment6,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlActvtn") )]
	pub orgnl_actvtn: OriginalActivation3Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl DebtorActivationAmendment5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgnl_biz_instr { val.validate()? }
		if let Some(ref val) = self.amdmnt_rsn { val.validate()? }
		self.amdmnt.validate()?;
		self.orgnl_actvtn.validate()?;
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// DebtorActivationAmendment6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DebtorActivationAmendment6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrActvtn", skip_serializing_if = "Option::is_none") )]
	pub dbtr_actvtn: Option<DebtorActivation6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ElctrncInvcData", skip_serializing_if = "Option::is_none") )]
	pub elctrnc_invc_data: Option<ElectronicInvoice1>,
}

impl DebtorActivationAmendment6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.dbtr_actvtn { val.validate()? }
		if let Some(ref val) = self.elctrnc_invc_data { val.validate()? }
		Ok(())
	}
}


// DebtorActivationAmendmentReason1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DebtorActivationAmendmentReason1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl DebtorActivationAmendmentReason1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// DebtorActivationAmendmentReason3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DebtorActivationAmendmentReason3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Orgtr", skip_serializing_if = "Option::is_none") )]
	pub orgtr: Option<RTPPartyIdentification2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn") )]
	pub rsn: DebtorActivationAmendmentReason1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<Vec<String>>,
}

impl DebtorActivationAmendmentReason3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgtr { val.validate()? }
		self.rsn.validate()?;
		if let Some(ref vec) = self.addtl_inf {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 105 {
					return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 105".to_string()));
				}
			}
		}
		Ok(())
	}
}


// DebtorActivationCancellation3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DebtorActivationCancellation3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlBizInstr", skip_serializing_if = "Option::is_none") )]
	pub orgnl_biz_instr: Option<OriginalBusinessInstruction1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CxlRsn", skip_serializing_if = "Option::is_none") )]
	pub cxl_rsn: Option<DebtorActivationCancellationReason3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlActvtn") )]
	pub orgnl_actvtn: OriginalActivation3Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl DebtorActivationCancellation3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgnl_biz_instr { val.validate()? }
		if let Some(ref val) = self.cxl_rsn { val.validate()? }
		self.orgnl_actvtn.validate()?;
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// DebtorActivationCancellationReason1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DebtorActivationCancellationReason1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl DebtorActivationCancellationReason1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// DebtorActivationCancellationReason3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DebtorActivationCancellationReason3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Orgtr", skip_serializing_if = "Option::is_none") )]
	pub orgtr: Option<RTPPartyIdentification2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn") )]
	pub rsn: DebtorActivationCancellationReason1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<Vec<String>>,
}

impl DebtorActivationCancellationReason3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgtr { val.validate()? }
		self.rsn.validate()?;
		if let Some(ref vec) = self.addtl_inf {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 105 {
					return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 105".to_string()));
				}
			}
		}
		Ok(())
	}
}


// DebtorActivationStatusReason1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DebtorActivationStatusReason1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl DebtorActivationStatusReason1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// DebtorActivationStatusReason3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DebtorActivationStatusReason3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Orgtr", skip_serializing_if = "Option::is_none") )]
	pub orgtr: Option<RTPPartyIdentification2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn") )]
	pub rsn: DebtorActivationStatusReason1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<Vec<String>>,
}

impl DebtorActivationStatusReason3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgtr { val.validate()? }
		self.rsn.validate()?;
		if let Some(ref vec) = self.addtl_inf {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 105 {
					return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 105".to_string()));
				}
			}
		}
		Ok(())
	}
}


// DefaultFundRequirement1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DefaultFundRequirement1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrMmbId") )]
	pub clr_mmb_id: GenericIdentification165,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SvcId", skip_serializing_if = "Option::is_none") )]
	pub svc_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveCurrencyAndAmount,
}

impl DefaultFundRequirement1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.clr_mmb_id.validate()?;
		if let Some(ref val) = self.svc_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "svc_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "svc_id exceeds the maximum length of 35".to_string()));
			}
		}
		self.amt.validate()?;
		Ok(())
	}
}


// DefinedAttributes1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DefinedAttributes1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "QtyDfndAttrbts", skip_serializing_if = "Option::is_none") )]
	pub qty_dfnd_attrbts: Option<FinancialInstrumentAttributes89>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValDfndAttrbts", skip_serializing_if = "Option::is_none") )]
	pub val_dfnd_attrbts: Option<FinancialInstrumentAttributes90>,
}

impl DefinedAttributes1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.qty_dfnd_attrbts { val.validate()? }
		if let Some(ref val) = self.val_dfnd_attrbts { val.validate()? }
		Ok(())
	}
}


// DeliveryInterconnectionPoint1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DeliveryInterconnectionPoint1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl DeliveryInterconnectionPoint1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			let pattern = Regex::new("[A-Z0-9\\-]{16}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "cd does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 52 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 52".to_string()));
			}
		}
		Ok(())
	}
}


// DeniedReason11 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DeniedReason11 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd") )]
	pub cd: DeniedReason16Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlRsnInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_rsn_inf: Option<String>,
}

impl DeniedReason11 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.cd.validate()?;
		if let Some(ref val) = self.addtl_rsn_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_rsn_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 210 {
				return Err(ValidationError::new(1002, "addtl_rsn_inf exceeds the maximum length of 210".to_string()));
			}
		}
		Ok(())
	}
}


// DeniedReason16Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DeniedReason16Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<DeniedReason4Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl DeniedReason16Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// DeniedReason4Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum DeniedReason4Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ADEA") )]
	CodeADEA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DCAN") )]
	CodeDCAN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DPRG") )]
	CodeDPRG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DREP") )]
	CodeDREP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DSET") )]
	CodeDSET,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LATE") )]
	CodeLATE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CDRG") )]
	CodeCDRG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CDCY") )]
	CodeCDCY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CDRE") )]
	CodeCDRE,
}

impl DeniedReason4Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// DeniedStatus16Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DeniedStatus16Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NoSpcfdRsn", skip_serializing_if = "Option::is_none") )]
	pub no_spcfd_rsn: Option<NoReasonCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<Vec<DeniedReason11>>,
}

impl DeniedStatus16Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.no_spcfd_rsn { val.validate()? }
		if let Some(ref vec) = self.rsn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// Deposit1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Deposit1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MtrtyDt") )]
	pub mtrty_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val") )]
	pub val: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtyId") )]
	pub ctr_pty_id: String,
}

impl Deposit1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.val.validate()?;
		let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
		if !pattern.is_match(&self.ctr_pty_id) {
			return Err(ValidationError::new(1005, "ctr_pty_id does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// DepositType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum DepositType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "FITE") )]
	CodeFITE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CALL") )]
	CodeCALL,
}

impl DepositType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Derivative3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Derivative3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DerivClssfctn") )]
	pub deriv_clssfctn: DerivativeClassification1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DerivUndrlygLeg") )]
	pub deriv_undrlyg_leg: Vec<DerivativeUnderlyingLeg1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OptnAttrbts", skip_serializing_if = "Option::is_none") )]
	pub optn_attrbts: Option<Option14>,
}

impl Derivative3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.deriv_clssfctn.validate()?;
		for item in &self.deriv_undrlyg_leg { item.validate()? }
		if let Some(ref val) = self.optn_attrbts { val.validate()? }
		Ok(())
	}
}


// Derivative3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Derivative3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cmmdty", skip_serializing_if = "Option::is_none") )]
	pub cmmdty: Option<CommodityDerivative4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstRate", skip_serializing_if = "Option::is_none") )]
	pub intrst_rate: Option<InterestRateDerivative5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FX", skip_serializing_if = "Option::is_none") )]
	pub fx: Option<ForeignExchangeDerivative2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Eqty", skip_serializing_if = "Option::is_none") )]
	pub eqty: Option<EquityDerivative2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctForDiff", skip_serializing_if = "Option::is_none") )]
	pub ctrct_for_diff: Option<ContractForDifference2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cdt", skip_serializing_if = "Option::is_none") )]
	pub cdt: Option<CreditDefaultSwapsDerivative4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EmssnAllwnc", skip_serializing_if = "Option::is_none") )]
	pub emssn_allwnc: Option<EmissionAllowanceProductType1Code>,
}

impl Derivative3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cmmdty { val.validate()? }
		if let Some(ref val) = self.intrst_rate { val.validate()? }
		if let Some(ref val) = self.fx { val.validate()? }
		if let Some(ref val) = self.eqty { val.validate()? }
		if let Some(ref val) = self.ctrct_for_diff { val.validate()? }
		if let Some(ref val) = self.cdt { val.validate()? }
		if let Some(ref val) = self.emssn_allwnc { val.validate()? }
		Ok(())
	}
}


// Derivative4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Derivative4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Futr", skip_serializing_if = "Option::is_none") )]
	pub futr: Option<Future4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Optn", skip_serializing_if = "Option::is_none") )]
	pub optn: Option<Option15>,
}

impl Derivative4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.futr { val.validate()? }
		if let Some(ref val) = self.optn { val.validate()? }
		Ok(())
	}
}


// DerivativeClassification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DerivativeClassification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AsstClss") )]
	pub asst_clss: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct", skip_serializing_if = "Option::is_none") )]
	pub base_pdct: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubCmmdty", skip_serializing_if = "Option::is_none") )]
	pub sub_cmmdty: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxTp", skip_serializing_if = "Option::is_none") )]
	pub tx_tp: Option<String>,
}

impl DerivativeClassification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.asst_clss.chars().count() < 1 {
			return Err(ValidationError::new(1001, "asst_clss is shorter than the minimum length of 1".to_string()));
		}
		if self.asst_clss.chars().count() > 35 {
			return Err(ValidationError::new(1002, "asst_clss exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.base_pdct {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "base_pdct is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "base_pdct exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.sub_pdct {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "sub_pdct is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "sub_pdct exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.sub_cmmdty {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "sub_cmmdty is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "sub_cmmdty exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.tx_tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tx_tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tx_tp exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// DerivativeCommodity2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DerivativeCommodity2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pdct") )]
	pub pdct: AssetClassCommodity3Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxTp", skip_serializing_if = "Option::is_none") )]
	pub tx_tp: Option<AssetClassTransactionType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FnlPricTp", skip_serializing_if = "Option::is_none") )]
	pub fnl_pric_tp: Option<AssetPriceType1Code>,
}

impl DerivativeCommodity2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pdct.validate()?;
		if let Some(ref val) = self.tx_tp { val.validate()? }
		if let Some(ref val) = self.fnl_pric_tp { val.validate()? }
		Ok(())
	}
}


// DerivativeEvent6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DerivativeEvent6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<DerivativeEventType3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<EventIdentifier1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TmStmp", skip_serializing_if = "Option::is_none") )]
	pub tm_stmp: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AmdmntInd", skip_serializing_if = "Option::is_none") )]
	pub amdmnt_ind: Option<bool>,
}

impl DerivativeEvent6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.id { val.validate()? }
		if let Some(ref val) = self.tm_stmp { val.validate()? }
		Ok(())
	}
}


// DerivativeEventType3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum DerivativeEventType3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ALOC") )]
	CodeALOC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CLRG") )]
	CodeCLRG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CLAL") )]
	CodeCLAL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "COMP") )]
	CodeCOMP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CORP") )]
	CodeCORP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CREV") )]
	CodeCREV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ETRM") )]
	CodeETRM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EXER") )]
	CodeEXER,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INCP") )]
	CodeINCP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NOVA") )]
	CodeNOVA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PTNG") )]
	CodePTNG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TRAD") )]
	CodeTRAD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UPDT") )]
	CodeUPDT,
}

impl DerivativeEventType3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// DerivativeForeignExchange2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DerivativeForeignExchange2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrNtnlCcy") )]
	pub othr_ntnl_ccy: String,
}

impl DerivativeForeignExchange2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.othr_ntnl_ccy) {
			return Err(ValidationError::new(1005, "othr_ntnl_ccy does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// DerivativeForeignExchange3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DerivativeForeignExchange3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FxTp", skip_serializing_if = "Option::is_none") )]
	pub fx_tp: Option<AssetFXSubProductType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrNtnlCcy", skip_serializing_if = "Option::is_none") )]
	pub othr_ntnl_ccy: Option<String>,
}

impl DerivativeForeignExchange3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.fx_tp { val.validate()? }
		if let Some(ref val) = self.othr_ntnl_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "othr_ntnl_ccy does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// DerivativeInstrument5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DerivativeInstrument5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "XpryDt", skip_serializing_if = "Option::is_none") )]
	pub xpry_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PricMltplr", skip_serializing_if = "Option::is_none") )]
	pub pric_mltplr: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UndrlygInstrm", skip_serializing_if = "Option::is_none") )]
	pub undrlyg_instrm: Option<FinancialInstrumentIdentification5Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OptnTp", skip_serializing_if = "Option::is_none") )]
	pub optn_tp: Option<OptionType2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StrkPric", skip_serializing_if = "Option::is_none") )]
	pub strk_pric: Option<SecuritiesTransactionPrice4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OptnExrcStyle", skip_serializing_if = "Option::is_none") )]
	pub optn_exrc_style: Option<OptionStyle7Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DlvryTp", skip_serializing_if = "Option::is_none") )]
	pub dlvry_tp: Option<PhysicalTransferType4Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AsstClssSpcfcAttrbts", skip_serializing_if = "Option::is_none") )]
	pub asst_clss_spcfc_attrbts: Option<AssetClass2>,
}

impl DerivativeInstrument5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.pric_mltplr {
			if *val < 0.000000 {
				return Err(ValidationError::new(1003, "pric_mltplr is less than the minimum value of 0.000000".to_string()));
			}
		}
		if let Some(ref val) = self.undrlyg_instrm { val.validate()? }
		if let Some(ref val) = self.optn_tp { val.validate()? }
		if let Some(ref val) = self.strk_pric { val.validate()? }
		if let Some(ref val) = self.optn_exrc_style { val.validate()? }
		if let Some(ref val) = self.dlvry_tp { val.validate()? }
		if let Some(ref val) = self.asst_clss_spcfc_attrbts { val.validate()? }
		Ok(())
	}
}


// DerivativeInstrument6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DerivativeInstrument6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "XpryDt", skip_serializing_if = "Option::is_none") )]
	pub xpry_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PricMltplr") )]
	pub pric_mltplr: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UndrlygInstrm") )]
	pub undrlyg_instrm: UnderlyingIdentification2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OptnTp", skip_serializing_if = "Option::is_none") )]
	pub optn_tp: Option<OptionType2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StrkPric", skip_serializing_if = "Option::is_none") )]
	pub strk_pric: Option<SecuritiesTransactionPrice4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OptnExrcStyle", skip_serializing_if = "Option::is_none") )]
	pub optn_exrc_style: Option<OptionStyle7Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DlvryTp") )]
	pub dlvry_tp: PhysicalTransferType4Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AsstClssSpcfcAttrbts", skip_serializing_if = "Option::is_none") )]
	pub asst_clss_spcfc_attrbts: Option<AssetClassAttributes1Choice>,
}

impl DerivativeInstrument6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.pric_mltplr < 0.000000 {
			return Err(ValidationError::new(1003, "pric_mltplr is less than the minimum value of 0.000000".to_string()));
		}
		self.undrlyg_instrm.validate()?;
		if let Some(ref val) = self.optn_tp { val.validate()? }
		if let Some(ref val) = self.strk_pric { val.validate()? }
		if let Some(ref val) = self.optn_exrc_style { val.validate()? }
		self.dlvry_tp.validate()?;
		if let Some(ref val) = self.asst_clss_spcfc_attrbts { val.validate()? }
		Ok(())
	}
}


// DerivativeInterest2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DerivativeInterest2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrNtnlCcy") )]
	pub othr_ntnl_ccy: String,
}

impl DerivativeInterest2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.othr_ntnl_ccy) {
			return Err(ValidationError::new(1005, "othr_ntnl_ccy does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// DerivativeInterest3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DerivativeInterest3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstRate") )]
	pub intrst_rate: FloatingInterestRate8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrstLegIntrstRate", skip_serializing_if = "Option::is_none") )]
	pub frst_leg_intrst_rate: Option<InterestRate8Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrNtnlCcy", skip_serializing_if = "Option::is_none") )]
	pub othr_ntnl_ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrLegIntrstRate", skip_serializing_if = "Option::is_none") )]
	pub othr_leg_intrst_rate: Option<InterestRate8Choice>,
}

impl DerivativeInterest3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.intrst_rate.validate()?;
		if let Some(ref val) = self.frst_leg_intrst_rate { val.validate()? }
		if let Some(ref val) = self.othr_ntnl_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "othr_ntnl_ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.othr_leg_intrst_rate { val.validate()? }
		Ok(())
	}
}


// DerivativePartyIdentification1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DerivativePartyIdentification1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctry", skip_serializing_if = "Option::is_none") )]
	pub ctry: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrySubDvsn", skip_serializing_if = "Option::is_none") )]
	pub ctry_sub_dvsn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LEI", skip_serializing_if = "Option::is_none") )]
	pub lei: Option<String>,
}

impl DerivativePartyIdentification1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ctry {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.ctry_sub_dvsn {
			let pattern = Regex::new("[A-Z]{2,2}\\-[0-9A-Z]{1,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry_sub_dvsn does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.lei {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "lei does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// DerivativeUnderlyingLeg1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DerivativeUnderlyingLeg1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctAttrbts") )]
	pub ctrct_attrbts: FinancialInstrumentAttributes88,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DfndAttrbts", skip_serializing_if = "Option::is_none") )]
	pub dfnd_attrbts: Option<DefinedAttributes1Choice>,
}

impl DerivativeUnderlyingLeg1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.ctrct_attrbts.validate()?;
		if let Some(ref val) = self.dfnd_attrbts { val.validate()? }
		Ok(())
	}
}


// DetailedAbnormalValuesStatistics4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DetailedAbnormalValuesStatistics4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DataSetActn", skip_serializing_if = "Option::is_none") )]
	pub data_set_actn: Option<ReportPeriodActivity1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rpt", skip_serializing_if = "Option::is_none") )]
	pub rpt: Option<DetailedTransactionStatistics28>,
}

impl DetailedAbnormalValuesStatistics4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.data_set_actn { val.validate()? }
		if let Some(ref val) = self.rpt { val.validate()? }
		Ok(())
	}
}


// DetailedMissingMarginInformationStatistics4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DetailedMissingMarginInformationStatistics4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DataSetActn", skip_serializing_if = "Option::is_none") )]
	pub data_set_actn: Option<ReportPeriodActivity1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rpt", skip_serializing_if = "Option::is_none") )]
	pub rpt: Option<DetailedTransactionStatistics26>,
}

impl DetailedMissingMarginInformationStatistics4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.data_set_actn { val.validate()? }
		if let Some(ref val) = self.rpt { val.validate()? }
		Ok(())
	}
}


// DetailedMissingValuationsStatistics4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DetailedMissingValuationsStatistics4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DataSetActn", skip_serializing_if = "Option::is_none") )]
	pub data_set_actn: Option<ReportPeriodActivity1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rpt", skip_serializing_if = "Option::is_none") )]
	pub rpt: Option<DetailedTransactionStatistics27>,
}

impl DetailedMissingValuationsStatistics4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.data_set_actn { val.validate()? }
		if let Some(ref val) = self.rpt { val.validate()? }
		Ok(())
	}
}


// DetailedReportStatistics5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DetailedReportStatistics5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNbOfRpts") )]
	pub ttl_nb_of_rpts: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNbOfRptsAccptd") )]
	pub ttl_nb_of_rpts_accptd: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNbOfRptsRjctd") )]
	pub ttl_nb_of_rpts_rjctd: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfRptsRjctdPerErr", skip_serializing_if = "Option::is_none") )]
	pub nb_of_rpts_rjctd_per_err: Option<Vec<NumberOfTransactionsPerValidationRule5>>,
}

impl DetailedReportStatistics5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[0-9]{1,15}").unwrap();
		if !pattern.is_match(&self.ttl_nb_of_rpts) {
			return Err(ValidationError::new(1005, "ttl_nb_of_rpts does not match the required pattern".to_string()));
		}
		let pattern = Regex::new("[0-9]{1,15}").unwrap();
		if !pattern.is_match(&self.ttl_nb_of_rpts_accptd) {
			return Err(ValidationError::new(1005, "ttl_nb_of_rpts_accptd does not match the required pattern".to_string()));
		}
		let pattern = Regex::new("[0-9]{1,15}").unwrap();
		if !pattern.is_match(&self.ttl_nb_of_rpts_rjctd) {
			return Err(ValidationError::new(1005, "ttl_nb_of_rpts_rjctd does not match the required pattern".to_string()));
		}
		if let Some(ref vec) = self.nb_of_rpts_rjctd_per_err { for item in vec { item.validate()? } }
		Ok(())
	}
}


// DetailedReportStatistics7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DetailedReportStatistics7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNbOfRpts") )]
	pub ttl_nb_of_rpts: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNbOfRptsAccptd") )]
	pub ttl_nb_of_rpts_accptd: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNbOfRptsRjctd") )]
	pub ttl_nb_of_rpts_rjctd: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfRptsRjctdPerErr", skip_serializing_if = "Option::is_none") )]
	pub nb_of_rpts_rjctd_per_err: Option<Vec<NumberOfTransactionsPerValidationRule6>>,
}

impl DetailedReportStatistics7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.ttl_nb_of_rpts < 0.000000 {
			return Err(ValidationError::new(1003, "ttl_nb_of_rpts is less than the minimum value of 0.000000".to_string()));
		}
		if self.ttl_nb_of_rpts_accptd < 0.000000 {
			return Err(ValidationError::new(1003, "ttl_nb_of_rpts_accptd is less than the minimum value of 0.000000".to_string()));
		}
		if self.ttl_nb_of_rpts_rjctd < 0.000000 {
			return Err(ValidationError::new(1003, "ttl_nb_of_rpts_rjctd is less than the minimum value of 0.000000".to_string()));
		}
		if let Some(ref vec) = self.nb_of_rpts_rjctd_per_err { for item in vec { item.validate()? } }
		Ok(())
	}
}


// DetailedStatisticsPerCounterparty17 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DetailedStatisticsPerCounterparty17 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RefDt") )]
	pub ref_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MssngValtn") )]
	pub mssng_valtn: DetailedMissingValuationsStatistics4Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MssngMrgnInf") )]
	pub mssng_mrgn_inf: DetailedMissingMarginInformationStatistics4Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AbnrmlVals") )]
	pub abnrml_vals: DetailedAbnormalValuesStatistics4Choice,
}

impl DetailedStatisticsPerCounterparty17 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.mssng_valtn.validate()?;
		self.mssng_mrgn_inf.validate()?;
		self.abnrml_vals.validate()?;
		Ok(())
	}
}


// DetailedStatisticsPerCounterparty19 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DetailedStatisticsPerCounterparty19 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RefDt") )]
	pub ref_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNbOfRpts") )]
	pub ttl_nb_of_rpts: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNbOfRptsAccptd") )]
	pub ttl_nb_of_rpts_accptd: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNbOfRptsRjctd") )]
	pub ttl_nb_of_rpts_rjctd: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNbOfTxs") )]
	pub ttl_nb_of_txs: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNbOfTxsAccptd") )]
	pub ttl_nb_of_txs_accptd: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNbOfTxsRjctd") )]
	pub ttl_nb_of_txs_rjctd: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlCrrctdRjctns", skip_serializing_if = "Option::is_none") )]
	pub ttl_crrctd_rjctns: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RjctnSttstcs") )]
	pub rjctn_sttstcs: Vec<RejectionStatistics9>,
}

impl DetailedStatisticsPerCounterparty19 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.ttl_nb_of_rpts < 0.000000 {
			return Err(ValidationError::new(1003, "ttl_nb_of_rpts is less than the minimum value of 0.000000".to_string()));
		}
		if self.ttl_nb_of_rpts_accptd < 0.000000 {
			return Err(ValidationError::new(1003, "ttl_nb_of_rpts_accptd is less than the minimum value of 0.000000".to_string()));
		}
		if self.ttl_nb_of_rpts_rjctd < 0.000000 {
			return Err(ValidationError::new(1003, "ttl_nb_of_rpts_rjctd is less than the minimum value of 0.000000".to_string()));
		}
		if self.ttl_nb_of_txs < 0.000000 {
			return Err(ValidationError::new(1003, "ttl_nb_of_txs is less than the minimum value of 0.000000".to_string()));
		}
		if self.ttl_nb_of_txs_accptd < 0.000000 {
			return Err(ValidationError::new(1003, "ttl_nb_of_txs_accptd is less than the minimum value of 0.000000".to_string()));
		}
		if self.ttl_nb_of_txs_rjctd < 0.000000 {
			return Err(ValidationError::new(1003, "ttl_nb_of_txs_rjctd is less than the minimum value of 0.000000".to_string()));
		}
		if let Some(ref val) = self.ttl_crrctd_rjctns {
			if *val < 0.000000 {
				return Err(ValidationError::new(1003, "ttl_crrctd_rjctns is less than the minimum value of 0.000000".to_string()));
			}
		}
		for item in &self.rjctn_sttstcs { item.validate()? }
		Ok(())
	}
}


// DetailedTransactionStatistics13 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DetailedTransactionStatistics13 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNbOfTxs") )]
	pub ttl_nb_of_txs: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNbOfTxsAccptd") )]
	pub ttl_nb_of_txs_accptd: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNbOfTxsRjctd") )]
	pub ttl_nb_of_txs_rjctd: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxsRjctnsRsn", skip_serializing_if = "Option::is_none") )]
	pub txs_rjctns_rsn: Option<Vec<RejectionReason53>>,
}

impl DetailedTransactionStatistics13 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[0-9]{1,15}").unwrap();
		if !pattern.is_match(&self.ttl_nb_of_txs) {
			return Err(ValidationError::new(1005, "ttl_nb_of_txs does not match the required pattern".to_string()));
		}
		let pattern = Regex::new("[0-9]{1,15}").unwrap();
		if !pattern.is_match(&self.ttl_nb_of_txs_accptd) {
			return Err(ValidationError::new(1005, "ttl_nb_of_txs_accptd does not match the required pattern".to_string()));
		}
		let pattern = Regex::new("[0-9]{1,15}").unwrap();
		if !pattern.is_match(&self.ttl_nb_of_txs_rjctd) {
			return Err(ValidationError::new(1005, "ttl_nb_of_txs_rjctd does not match the required pattern".to_string()));
		}
		if let Some(ref vec) = self.txs_rjctns_rsn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// DetailedTransactionStatistics26 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DetailedTransactionStatistics26 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfOutsdngDerivs") )]
	pub nb_of_outsdng_derivs: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfOutsdngDerivsWthNoMrgnInf") )]
	pub nb_of_outsdng_derivs_wth_no_mrgn_inf: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfOutsdngDerivsWthOutdtdMrgnInf") )]
	pub nb_of_outsdng_derivs_wth_outdtd_mrgn_inf: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Wrnngs") )]
	pub wrnngs: Vec<MissingMarginData2>,
}

impl DetailedTransactionStatistics26 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		for item in &self.wrnngs { item.validate()? }
		Ok(())
	}
}


// DetailedTransactionStatistics27 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DetailedTransactionStatistics27 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfOutsdngDerivs") )]
	pub nb_of_outsdng_derivs: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfOutsdngDerivsWthNoValtn") )]
	pub nb_of_outsdng_derivs_wth_no_valtn: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfOutsdngDerivsWthOutdtdValtn") )]
	pub nb_of_outsdng_derivs_wth_outdtd_valtn: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Wrnngs") )]
	pub wrnngs: Vec<MissingValuationsData2>,
}

impl DetailedTransactionStatistics27 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		for item in &self.wrnngs { item.validate()? }
		Ok(())
	}
}


// DetailedTransactionStatistics28 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DetailedTransactionStatistics28 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfDerivsRptd") )]
	pub nb_of_derivs_rptd: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfDerivsRptdWthOtlrs") )]
	pub nb_of_derivs_rptd_wth_otlrs: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Wrnngs") )]
	pub wrnngs: Vec<AbnormalValuesData4>,
}

impl DetailedTransactionStatistics28 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		for item in &self.wrnngs { item.validate()? }
		Ok(())
	}
}


// DetailedTransactionStatistics2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DetailedTransactionStatistics2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DataSetActn", skip_serializing_if = "Option::is_none") )]
	pub data_set_actn: Option<ReportPeriodActivity1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtldSttstcs", skip_serializing_if = "Option::is_none") )]
	pub dtld_sttstcs: Option<DetailedTransactionStatistics13>,
}

impl DetailedTransactionStatistics2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.data_set_actn { val.validate()? }
		if let Some(ref val) = self.dtld_sttstcs { val.validate()? }
		Ok(())
	}
}


// DetailedTransactionStatistics30 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DetailedTransactionStatistics30 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNbOfTxs") )]
	pub ttl_nb_of_txs: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNbOfTxsAccptd") )]
	pub ttl_nb_of_txs_accptd: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNbOfTxsRjctd") )]
	pub ttl_nb_of_txs_rjctd: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlCrrctdRjctns", skip_serializing_if = "Option::is_none") )]
	pub ttl_crrctd_rjctns: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxsRjctnsRsn", skip_serializing_if = "Option::is_none") )]
	pub txs_rjctns_rsn: Option<Vec<RejectionReason71>>,
}

impl DetailedTransactionStatistics30 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.ttl_nb_of_txs < 0.000000 {
			return Err(ValidationError::new(1003, "ttl_nb_of_txs is less than the minimum value of 0.000000".to_string()));
		}
		if self.ttl_nb_of_txs_accptd < 0.000000 {
			return Err(ValidationError::new(1003, "ttl_nb_of_txs_accptd is less than the minimum value of 0.000000".to_string()));
		}
		if self.ttl_nb_of_txs_rjctd < 0.000000 {
			return Err(ValidationError::new(1003, "ttl_nb_of_txs_rjctd is less than the minimum value of 0.000000".to_string()));
		}
		if let Some(ref val) = self.ttl_crrctd_rjctns {
			if *val < 0.000000 {
				return Err(ValidationError::new(1003, "ttl_crrctd_rjctns is less than the minimum value of 0.000000".to_string()));
			}
		}
		if let Some(ref vec) = self.txs_rjctns_rsn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// DetailedTransactionStatistics7Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DetailedTransactionStatistics7Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DataSetActn", skip_serializing_if = "Option::is_none") )]
	pub data_set_actn: Option<ReportPeriodActivity1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtldSttstcs", skip_serializing_if = "Option::is_none") )]
	pub dtld_sttstcs: Option<DetailedTransactionStatistics30>,
}

impl DetailedTransactionStatistics7Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.data_set_actn { val.validate()? }
		if let Some(ref val) = self.dtld_sttstcs { val.validate()? }
		Ok(())
	}
}


// DigitalTokenAmount2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DigitalTokenAmount2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Idr") )]
	pub idr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Unit", skip_serializing_if = "Option::is_none") )]
	pub unit: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Desc", skip_serializing_if = "Option::is_none") )]
	pub desc: Option<String>,
}

impl DigitalTokenAmount2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[1-9B-DF-HJ-NP-XZ][0-9B-DF-HJ-NP-XZ]{8,8}").unwrap();
		if !pattern.is_match(&self.idr) {
			return Err(ValidationError::new(1005, "idr does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.desc {
			if val.chars().count() > 30 {
				return Err(ValidationError::new(1002, "desc exceeds the maximum length of 30".to_string()));
			}
		}
		Ok(())
	}
}


// DirectDebitInstructionDetails3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DirectDebitInstructionDetails3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MndtId") )]
	pub mndt_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AutomtdDrctDbtInstrInd", skip_serializing_if = "Option::is_none") )]
	pub automtd_drct_dbt_instr_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DrctDbtTrfblInd", skip_serializing_if = "Option::is_none") )]
	pub drct_dbt_trfbl_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cdtr") )]
	pub cdtr: PartyIdentification272,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LastColltnCcyAmt", skip_serializing_if = "Option::is_none") )]
	pub last_colltn_ccy_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LastColltnDt", skip_serializing_if = "Option::is_none") )]
	pub last_colltn_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrDtls", skip_serializing_if = "Option::is_none") )]
	pub othr_dtls: Option<Vec<TransferInstruction1>>,
}

impl DirectDebitInstructionDetails3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.mndt_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "mndt_id is shorter than the minimum length of 1".to_string()));
		}
		if self.mndt_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "mndt_id exceeds the maximum length of 35".to_string()));
		}
		self.cdtr.validate()?;
		if let Some(ref val) = self.last_colltn_ccy_amt { val.validate()? }
		if let Some(ref vec) = self.othr_dtls { for item in vec { item.validate()? } }
		Ok(())
	}
}


// DirectDebitMandate7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DirectDebitMandate7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAcct") )]
	pub dbtr_acct: AccountIdentificationAndName5,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dbtr", skip_serializing_if = "Option::is_none") )]
	pub dbtr: Option<PartyIdentification125Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrTaxIdNb", skip_serializing_if = "Option::is_none") )]
	pub dbtr_tax_id_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrNtlRegnNb", skip_serializing_if = "Option::is_none") )]
	pub dbtr_ntl_regn_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cdtr", skip_serializing_if = "Option::is_none") )]
	pub cdtr: Option<PartyIdentification125Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgt") )]
	pub dbtr_agt: FinancialInstitutionIdentification11Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgtBrnch", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt_brnch: Option<BranchData4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgt", skip_serializing_if = "Option::is_none") )]
	pub cdtr_agt: Option<FinancialInstitutionIdentification11Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgtBrnch", skip_serializing_if = "Option::is_none") )]
	pub cdtr_agt_brnch: Option<BranchData4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegnId", skip_serializing_if = "Option::is_none") )]
	pub regn_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MndtId", skip_serializing_if = "Option::is_none") )]
	pub mndt_id: Option<String>,
}

impl DirectDebitMandate7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.dbtr_acct.validate()?;
		if let Some(ref val) = self.dbtr { val.validate()? }
		if let Some(ref val) = self.dbtr_tax_id_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "dbtr_tax_id_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "dbtr_tax_id_nb exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.dbtr_ntl_regn_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "dbtr_ntl_regn_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "dbtr_ntl_regn_nb exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.cdtr { val.validate()? }
		self.dbtr_agt.validate()?;
		if let Some(ref val) = self.dbtr_agt_brnch { val.validate()? }
		if let Some(ref val) = self.cdtr_agt { val.validate()? }
		if let Some(ref val) = self.cdtr_agt_brnch { val.validate()? }
		if let Some(ref val) = self.regn_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "regn_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "regn_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.mndt_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mndt_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "mndt_id exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// DirectDebitTransaction12 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DirectDebitTransaction12 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MndtRltdInf", skip_serializing_if = "Option::is_none") )]
	pub mndt_rltd_inf: Option<MandateRelatedInformation16>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrSchmeId", skip_serializing_if = "Option::is_none") )]
	pub cdtr_schme_id: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PreNtfctnId", skip_serializing_if = "Option::is_none") )]
	pub pre_ntfctn_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PreNtfctnDt", skip_serializing_if = "Option::is_none") )]
	pub pre_ntfctn_dt: Option<String>,
}

impl DirectDebitTransaction12 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mndt_rltd_inf { val.validate()? }
		if let Some(ref val) = self.cdtr_schme_id { val.validate()? }
		if let Some(ref val) = self.pre_ntfctn_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pre_ntfctn_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "pre_ntfctn_id exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// DirectDebitTransactionInformation31 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DirectDebitTransactionInformation31 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtId") )]
	pub pmt_id: PaymentIdentification13,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtTpInf", skip_serializing_if = "Option::is_none") )]
	pub pmt_tp_inf: Option<PaymentTypeInformation27>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBkSttlmAmt") )]
	pub intr_bk_sttlm_amt: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBkSttlmDt", skip_serializing_if = "Option::is_none") )]
	pub intr_bk_sttlm_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmPrty", skip_serializing_if = "Option::is_none") )]
	pub sttlm_prty: Option<Priority3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmTmIndctn", skip_serializing_if = "Option::is_none") )]
	pub sttlm_tm_indctn: Option<SettlementDateTimeIndication1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstdAmt", skip_serializing_if = "Option::is_none") )]
	pub instd_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XchgRate", skip_serializing_if = "Option::is_none") )]
	pub xchg_rate: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgBr") )]
	pub chrg_br: ChargeBearerType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsInf", skip_serializing_if = "Option::is_none") )]
	pub chrgs_inf: Option<Vec<Charges16>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdColltnDt", skip_serializing_if = "Option::is_none") )]
	pub reqd_colltn_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DrctDbtTx", skip_serializing_if = "Option::is_none") )]
	pub drct_dbt_tx: Option<DirectDebitTransaction12>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cdtr") )]
	pub cdtr: PartyIdentification272,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAcct", skip_serializing_if = "Option::is_none") )]
	pub cdtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgt") )]
	pub cdtr_agt: BranchAndFinancialInstitutionIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub cdtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtCdtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_cdtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitgPty", skip_serializing_if = "Option::is_none") )]
	pub initg_pty: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstgAgt", skip_serializing_if = "Option::is_none") )]
	pub instg_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstdAgt", skip_serializing_if = "Option::is_none") )]
	pub instd_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt1", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt1: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt1Acct", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt1_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt2", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt2: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt2Acct", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt2_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt3", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt3: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt3Acct", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt3_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dbtr") )]
	pub dbtr: PartyIdentification272,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAcct") )]
	pub dbtr_acct: CashAccount40,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgt") )]
	pub dbtr_agt: BranchAndFinancialInstitutionIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtDbtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_dbtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Purp", skip_serializing_if = "Option::is_none") )]
	pub purp: Option<Purpose2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RgltryRptg", skip_serializing_if = "Option::is_none") )]
	pub rgltry_rptg: Option<Vec<RegulatoryReporting3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdRmtInf", skip_serializing_if = "Option::is_none") )]
	pub rltd_rmt_inf: Option<Vec<RemittanceLocation8>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RmtInf", skip_serializing_if = "Option::is_none") )]
	pub rmt_inf: Option<RemittanceInformation22>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl DirectDebitTransactionInformation31 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pmt_id.validate()?;
		if let Some(ref val) = self.pmt_tp_inf { val.validate()? }
		self.intr_bk_sttlm_amt.validate()?;
		if let Some(ref val) = self.sttlm_prty { val.validate()? }
		if let Some(ref val) = self.sttlm_tm_indctn { val.validate()? }
		if let Some(ref val) = self.instd_amt { val.validate()? }
		self.chrg_br.validate()?;
		if let Some(ref vec) = self.chrgs_inf { for item in vec { item.validate()? } }
		if let Some(ref val) = self.drct_dbt_tx { val.validate()? }
		self.cdtr.validate()?;
		if let Some(ref val) = self.cdtr_acct { val.validate()? }
		self.cdtr_agt.validate()?;
		if let Some(ref val) = self.cdtr_agt_acct { val.validate()? }
		if let Some(ref val) = self.ultmt_cdtr { val.validate()? }
		if let Some(ref val) = self.initg_pty { val.validate()? }
		if let Some(ref val) = self.instg_agt { val.validate()? }
		if let Some(ref val) = self.instd_agt { val.validate()? }
		if let Some(ref val) = self.intrmy_agt1 { val.validate()? }
		if let Some(ref val) = self.intrmy_agt1_acct { val.validate()? }
		if let Some(ref val) = self.intrmy_agt2 { val.validate()? }
		if let Some(ref val) = self.intrmy_agt2_acct { val.validate()? }
		if let Some(ref val) = self.intrmy_agt3 { val.validate()? }
		if let Some(ref val) = self.intrmy_agt3_acct { val.validate()? }
		self.dbtr.validate()?;
		self.dbtr_acct.validate()?;
		self.dbtr_agt.validate()?;
		if let Some(ref val) = self.dbtr_agt_acct { val.validate()? }
		if let Some(ref val) = self.ultmt_dbtr { val.validate()? }
		if let Some(ref val) = self.purp { val.validate()? }
		if let Some(ref vec) = self.rgltry_rptg { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.rltd_rmt_inf { for item in vec { item.validate()? } }
		if let Some(ref val) = self.rmt_inf { val.validate()? }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// DirectDebitTransactionInformation32 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DirectDebitTransactionInformation32 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtId") )]
	pub pmt_id: PaymentIdentification6,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtTpInf", skip_serializing_if = "Option::is_none") )]
	pub pmt_tp_inf: Option<PaymentTypeInformation29>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstdAmt") )]
	pub instd_amt: ActiveOrHistoricCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgBr", skip_serializing_if = "Option::is_none") )]
	pub chrg_br: Option<ChargeBearerType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DrctDbtTx", skip_serializing_if = "Option::is_none") )]
	pub drct_dbt_tx: Option<DirectDebitTransaction12>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtCdtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_cdtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgt") )]
	pub dbtr_agt: BranchAndFinancialInstitutionIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dbtr") )]
	pub dbtr: PartyIdentification272,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAcct") )]
	pub dbtr_acct: CashAccount40,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtDbtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_dbtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrForCdtrAgt", skip_serializing_if = "Option::is_none") )]
	pub instr_for_cdtr_agt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Purp", skip_serializing_if = "Option::is_none") )]
	pub purp: Option<Purpose2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RgltryRptg", skip_serializing_if = "Option::is_none") )]
	pub rgltry_rptg: Option<Vec<RegulatoryReporting3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tax", skip_serializing_if = "Option::is_none") )]
	pub tax: Option<TaxData1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdRmtInf", skip_serializing_if = "Option::is_none") )]
	pub rltd_rmt_inf: Option<Vec<RemittanceLocation8>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RmtInf", skip_serializing_if = "Option::is_none") )]
	pub rmt_inf: Option<RemittanceInformation22>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl DirectDebitTransactionInformation32 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pmt_id.validate()?;
		if let Some(ref val) = self.pmt_tp_inf { val.validate()? }
		self.instd_amt.validate()?;
		if let Some(ref val) = self.chrg_br { val.validate()? }
		if let Some(ref val) = self.drct_dbt_tx { val.validate()? }
		if let Some(ref val) = self.ultmt_cdtr { val.validate()? }
		self.dbtr_agt.validate()?;
		if let Some(ref val) = self.dbtr_agt_acct { val.validate()? }
		self.dbtr.validate()?;
		self.dbtr_acct.validate()?;
		if let Some(ref val) = self.ultmt_dbtr { val.validate()? }
		if let Some(ref val) = self.instr_for_cdtr_agt {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "instr_for_cdtr_agt is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "instr_for_cdtr_agt exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.purp { val.validate()? }
		if let Some(ref vec) = self.rgltry_rptg { for item in vec { item.validate()? } }
		if let Some(ref val) = self.tax { val.validate()? }
		if let Some(ref vec) = self.rltd_rmt_inf { for item in vec { item.validate()? } }
		if let Some(ref val) = self.rmt_inf { val.validate()? }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// DirectDebitTransactionInformation33 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DirectDebitTransactionInformation33 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtId") )]
	pub pmt_id: PaymentIdentification13,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtTpInf", skip_serializing_if = "Option::is_none") )]
	pub pmt_tp_inf: Option<PaymentTypeInformation28>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBkSttlmAmt") )]
	pub intr_bk_sttlm_amt: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBkSttlmDt", skip_serializing_if = "Option::is_none") )]
	pub intr_bk_sttlm_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmPrty", skip_serializing_if = "Option::is_none") )]
	pub sttlm_prty: Option<Priority3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmTmIndctn", skip_serializing_if = "Option::is_none") )]
	pub sttlm_tm_indctn: Option<SettlementDateTimeIndication1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmTmReq", skip_serializing_if = "Option::is_none") )]
	pub sttlm_tm_req: Option<SettlementTimeRequest2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtDbtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_dbtr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dbtr") )]
	pub dbtr: BranchAndFinancialInstitutionIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgt", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrForDbtrAgt", skip_serializing_if = "Option::is_none") )]
	pub instr_for_dbtr_agt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Purp", skip_serializing_if = "Option::is_none") )]
	pub purp: Option<Purpose2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RmtInf", skip_serializing_if = "Option::is_none") )]
	pub rmt_inf: Option<RemittanceInformation2>,
}

impl DirectDebitTransactionInformation33 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pmt_id.validate()?;
		if let Some(ref val) = self.pmt_tp_inf { val.validate()? }
		self.intr_bk_sttlm_amt.validate()?;
		if let Some(ref val) = self.sttlm_prty { val.validate()? }
		if let Some(ref val) = self.sttlm_tm_indctn { val.validate()? }
		if let Some(ref val) = self.sttlm_tm_req { val.validate()? }
		if let Some(ref val) = self.ultmt_dbtr { val.validate()? }
		self.dbtr.validate()?;
		if let Some(ref val) = self.dbtr_acct { val.validate()? }
		if let Some(ref val) = self.dbtr_agt { val.validate()? }
		if let Some(ref val) = self.dbtr_agt_acct { val.validate()? }
		if let Some(ref val) = self.instr_for_dbtr_agt {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "instr_for_dbtr_agt is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 210 {
				return Err(ValidationError::new(1002, "instr_for_dbtr_agt exceeds the maximum length of 210".to_string()));
			}
		}
		if let Some(ref val) = self.purp { val.validate()? }
		if let Some(ref val) = self.rmt_inf { val.validate()? }
		Ok(())
	}
}


// Direction2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Direction2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DrctnOfTheFrstLeg") )]
	pub drctn_of_the_frst_leg: OptionParty3Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DrctnOfTheScndLeg", skip_serializing_if = "Option::is_none") )]
	pub drctn_of_the_scnd_leg: Option<OptionParty3Code>,
}

impl Direction2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.drctn_of_the_frst_leg.validate()?;
		if let Some(ref val) = self.drctn_of_the_scnd_leg { val.validate()? }
		Ok(())
	}
}


// Direction4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Direction4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Drctn", skip_serializing_if = "Option::is_none") )]
	pub drctn: Option<Direction2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtySd", skip_serializing_if = "Option::is_none") )]
	pub ctr_pty_sd: Option<OptionParty1Code>,
}

impl Direction4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.drctn { val.validate()? }
		if let Some(ref val) = self.ctr_pty_sd { val.validate()? }
		Ok(())
	}
}


// DisabledReason2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum DisabledReason2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CLOS") )]
	CodeCLOS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BKRP") )]
	CodeBKRP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CMMT") )]
	CodeCMMT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CNFS") )]
	CodeCNFS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MORT") )]
	CodeMORT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PCOM") )]
	CodePCOM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PLDG") )]
	CodePLDG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TRPE") )]
	CodeTRPE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SANC") )]
	CodeSANC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TRAN") )]
	CodeTRAN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REJT") )]
	CodeREJT,
}

impl DisabledReason2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// DisabledStatusReason1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DisabledStatusReason1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd") )]
	pub cd: DisabledStatusReason2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
}

impl DisabledStatusReason1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.cd.validate()?;
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 350".to_string()));
			}
		}
		Ok(())
	}
}


// DisabledStatusReason1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DisabledStatusReason1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NoSpcfdRsn", skip_serializing_if = "Option::is_none") )]
	pub no_spcfd_rsn: Option<NoReasonCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<Vec<DisabledStatusReason1>>,
}

impl DisabledStatusReason1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.no_spcfd_rsn { val.validate()? }
		if let Some(ref vec) = self.rsn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// DisabledStatusReason2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DisabledStatusReason2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<DisabledReason2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification36>,
}

impl DisabledStatusReason2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// DiscountAmountAndType1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DiscountAmountAndType1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<DiscountAmountType1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveOrHistoricCurrencyAndAmount,
}

impl DiscountAmountAndType1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tp { val.validate()? }
		self.amt.validate()?;
		Ok(())
	}
}


// DiscountAmountType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DiscountAmountType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl DiscountAmountType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// DisplayCapabilities1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DisplayCapabilities1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DispTp") )]
	pub disp_tp: UserInterface2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfLines") )]
	pub nb_of_lines: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LineWidth") )]
	pub line_width: String,
}

impl DisplayCapabilities1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.disp_tp.validate()?;
		let pattern = Regex::new("[0-9]{1,3}").unwrap();
		if !pattern.is_match(&self.nb_of_lines) {
			return Err(ValidationError::new(1005, "nb_of_lines does not match the required pattern".to_string()));
		}
		let pattern = Regex::new("[0-9]{1,3}").unwrap();
		if !pattern.is_match(&self.line_width) {
			return Err(ValidationError::new(1005, "line_width does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// DisseminationData1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DisseminationData1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DssmntnIdr") )]
	pub dssmntn_idr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlDssmntnIdr", skip_serializing_if = "Option::is_none") )]
	pub orgnl_dssmntn_idr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TmStmp") )]
	pub tm_stmp: String,
}

impl DisseminationData1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.dssmntn_idr.chars().count() < 1 {
			return Err(ValidationError::new(1001, "dssmntn_idr is shorter than the minimum length of 1".to_string()));
		}
		if self.dssmntn_idr.chars().count() > 52 {
			return Err(ValidationError::new(1002, "dssmntn_idr exceeds the maximum length of 52".to_string()));
		}
		if let Some(ref val) = self.orgnl_dssmntn_idr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_dssmntn_idr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 52 {
				return Err(ValidationError::new(1002, "orgnl_dssmntn_idr exceeds the maximum length of 52".to_string()));
			}
		}
		Ok(())
	}
}


// DistributionPolicy1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum DistributionPolicy1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "DIST") )]
	CodeDIST,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACCU") )]
	CodeACCU,
}

impl DistributionPolicy1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// DistributionPolicy2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DistributionPolicy2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<DistributionPolicy1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl DistributionPolicy2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// DistributionStrategy1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DistributionStrategy1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExctnOnly", skip_serializing_if = "Option::is_none") )]
	pub exctn_only: Option<DistributionStrategy1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExctnWthApprprtnssTstOrNonAdvsdSvcs", skip_serializing_if = "Option::is_none") )]
	pub exctn_wth_apprprtnss_tst_or_non_advsd_svcs: Option<DistributionStrategy1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstmtAdvc", skip_serializing_if = "Option::is_none") )]
	pub invstmt_advc: Option<DistributionStrategy1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtflMgmt", skip_serializing_if = "Option::is_none") )]
	pub prtfl_mgmt: Option<DistributionStrategy1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<OtherDistributionStrategy1>,
}

impl DistributionStrategy1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.exctn_only { val.validate()? }
		if let Some(ref val) = self.exctn_wth_apprprtnss_tst_or_non_advsd_svcs { val.validate()? }
		if let Some(ref val) = self.invstmt_advc { val.validate()? }
		if let Some(ref val) = self.prtfl_mgmt { val.validate()? }
		if let Some(ref val) = self.othr { val.validate()? }
		Ok(())
	}
}


// DistributionStrategy1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DistributionStrategy1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<InvestorType3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl DistributionStrategy1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// DividendPolicy1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum DividendPolicy1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CASH") )]
	CodeCASH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UNIT") )]
	CodeUNIT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BOTH") )]
	CodeBOTH,
}

impl DividendPolicy1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Document12 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Document12 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: DocumentType1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IsseDt") )]
	pub isse_dt: DateAndDateTime2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LangCd", skip_serializing_if = "Option::is_none") )]
	pub lang_cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Frmt") )]
	pub frmt: DocumentFormat1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FileNm", skip_serializing_if = "Option::is_none") )]
	pub file_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DgtlSgntr", skip_serializing_if = "Option::is_none") )]
	pub dgtl_sgntr: Option<PartyAndSignature3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nclsr") )]
	pub nclsr: String,
}

impl Document12 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tp.validate()?;
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		self.isse_dt.validate()?;
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 140".to_string()));
			}
		}
		self.frmt.validate()?;
		if let Some(ref val) = self.file_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "file_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "file_nm exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.dgtl_sgntr { val.validate()? }
		if self.nclsr.chars().count() < 1 {
			return Err(ValidationError::new(1001, "nclsr is shorter than the minimum length of 1".to_string()));
		}
		if self.nclsr.chars().count() > 10485760 {
			return Err(ValidationError::new(1002, "nclsr exceeds the maximum length of 10485760".to_string()));
		}
		Ok(())
	}
}


// Document15 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Document15 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: DocumentType1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IsseDt") )]
	pub isse_dt: DateAndDateTime2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LangCd", skip_serializing_if = "Option::is_none") )]
	pub lang_cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Frmt") )]
	pub frmt: DocumentFormat1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FileNm", skip_serializing_if = "Option::is_none") )]
	pub file_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DgtlSgntr", skip_serializing_if = "Option::is_none") )]
	pub dgtl_sgntr: Option<PartyAndSignature4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nclsr") )]
	pub nclsr: String,
}

impl Document15 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tp.validate()?;
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		self.isse_dt.validate()?;
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 140".to_string()));
			}
		}
		self.frmt.validate()?;
		if let Some(ref val) = self.file_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "file_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "file_nm exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.dgtl_sgntr { val.validate()? }
		if self.nclsr.chars().count() < 1 {
			return Err(ValidationError::new(1001, "nclsr is shorter than the minimum length of 1".to_string()));
		}
		if self.nclsr.chars().count() > 10485760 {
			return Err(ValidationError::new(1002, "nclsr exceeds the maximum length of 10485760".to_string()));
		}
		Ok(())
	}
}


// DocumentAdjustment1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DocumentAdjustment1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveOrHistoricCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbtInd", skip_serializing_if = "Option::is_none") )]
	pub cdt_dbt_ind: Option<CreditDebitCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
}

impl DocumentAdjustment1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.amt.validate()?;
		if let Some(ref val) = self.cdt_dbt_ind { val.validate()? }
		if let Some(ref val) = self.rsn {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rsn is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "rsn exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// DocumentAmendment1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DocumentAmendment1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CrrctnId") )]
	pub crrctn_id: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlDocId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_doc_id: Option<String>,
}

impl DocumentAmendment1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgnl_doc_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_doc_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_doc_id exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// DocumentAmount1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DocumentAmount1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: DocumentAmountType1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveOrHistoricCurrencyAndAmount,
}

impl DocumentAmount1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tp.validate()?;
		self.amt.validate()?;
		Ok(())
	}
}


// DocumentAmountType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DocumentAmountType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl DocumentAmountType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// DocumentEntryAmendment1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DocumentEntryAmendment1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CrrctgNtryNb") )]
	pub crrctg_ntry_nb: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlDoc") )]
	pub orgnl_doc: DocumentIdentification28,
}

impl DocumentEntryAmendment1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.orgnl_doc.validate()?;
		Ok(())
	}
}


// DocumentFormat1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DocumentFormat1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification1>,
}

impl DocumentFormat1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// DocumentFormat2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DocumentFormat2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification1>,
}

impl DocumentFormat2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// DocumentGeneralInformation2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DocumentGeneralInformation2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DocTp") )]
	pub doc_tp: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DocNb") )]
	pub doc_nb: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SndrRcvrSeqId", skip_serializing_if = "Option::is_none") )]
	pub sndr_rcvr_seq_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IsseDt", skip_serializing_if = "Option::is_none") )]
	pub isse_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "URL", skip_serializing_if = "Option::is_none") )]
	pub url: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AttchdBinryFile", skip_serializing_if = "Option::is_none") )]
	pub attchd_binry_file: Option<Vec<BinaryFile1>>,
}

impl DocumentGeneralInformation2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.doc_tp.chars().count() < 1 {
			return Err(ValidationError::new(1001, "doc_tp is shorter than the minimum length of 1".to_string()));
		}
		if self.doc_tp.chars().count() > 4 {
			return Err(ValidationError::new(1002, "doc_tp exceeds the maximum length of 4".to_string()));
		}
		if self.doc_nb.chars().count() < 1 {
			return Err(ValidationError::new(1001, "doc_nb is shorter than the minimum length of 1".to_string()));
		}
		if self.doc_nb.chars().count() > 35 {
			return Err(ValidationError::new(1002, "doc_nb exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.sndr_rcvr_seq_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "sndr_rcvr_seq_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "sndr_rcvr_seq_id exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.url {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "url is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 256 {
				return Err(ValidationError::new(1002, "url exceeds the maximum length of 256".to_string()));
			}
		}
		if let Some(ref vec) = self.attchd_binry_file { for item in vec { item.validate()? } }
		Ok(())
	}
}


// DocumentGeneralInformation5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DocumentGeneralInformation5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DocTp") )]
	pub doc_tp: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DocNb") )]
	pub doc_nb: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DocNm", skip_serializing_if = "Option::is_none") )]
	pub doc_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SndrRcvrSeqId", skip_serializing_if = "Option::is_none") )]
	pub sndr_rcvr_seq_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IsseDt", skip_serializing_if = "Option::is_none") )]
	pub isse_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "URL", skip_serializing_if = "Option::is_none") )]
	pub url: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LkFileHash", skip_serializing_if = "Option::is_none") )]
	pub lk_file_hash: Option<SignatureEnvelopeReference>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AttchdBinryFile") )]
	pub attchd_binry_file: BinaryFile1,
}

impl DocumentGeneralInformation5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.doc_tp.chars().count() < 1 {
			return Err(ValidationError::new(1001, "doc_tp is shorter than the minimum length of 1".to_string()));
		}
		if self.doc_tp.chars().count() > 4 {
			return Err(ValidationError::new(1002, "doc_tp exceeds the maximum length of 4".to_string()));
		}
		if self.doc_nb.chars().count() < 1 {
			return Err(ValidationError::new(1001, "doc_nb is shorter than the minimum length of 1".to_string()));
		}
		if self.doc_nb.chars().count() > 35 {
			return Err(ValidationError::new(1002, "doc_nb exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.doc_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "doc_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "doc_nm exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.sndr_rcvr_seq_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "sndr_rcvr_seq_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "sndr_rcvr_seq_id exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.url {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "url is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 256 {
				return Err(ValidationError::new(1002, "url exceeds the maximum length of 256".to_string()));
			}
		}
		if let Some(ref val) = self.lk_file_hash { val.validate()? }
		self.attchd_binry_file.validate()?;
		Ok(())
	}
}


// DocumentIdentification22 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DocumentIdentification22 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtOfIsse", skip_serializing_if = "Option::is_none") )]
	pub dt_of_isse: Option<String>,
}

impl DocumentIdentification22 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		Ok(())
	}
}


// DocumentIdentification28 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DocumentIdentification28 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtOfIsse") )]
	pub dt_of_isse: String,
}

impl DocumentIdentification28 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// DocumentIdentification29 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DocumentIdentification29 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtOfIsse") )]
	pub dt_of_isse: String,
}

impl DocumentIdentification29 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		Ok(())
	}
}


// DocumentIdentification35 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DocumentIdentification35 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtOfIsse", skip_serializing_if = "Option::is_none") )]
	pub dt_of_isse: Option<String>,
}

impl DocumentIdentification35 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// DocumentIdentification51 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DocumentIdentification51 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm", skip_serializing_if = "Option::is_none") )]
	pub cre_dt_tm: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CpyDplct", skip_serializing_if = "Option::is_none") )]
	pub cpy_dplct: Option<CopyDuplicate1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgOrgtr", skip_serializing_if = "Option::is_none") )]
	pub msg_orgtr: Option<PartyIdentification136>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgRcpt", skip_serializing_if = "Option::is_none") )]
	pub msg_rcpt: Option<PartyIdentification136>,
}

impl DocumentIdentification51 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.cre_dt_tm { val.validate()? }
		if let Some(ref val) = self.cpy_dplct { val.validate()? }
		if let Some(ref val) = self.msg_orgtr { val.validate()? }
		if let Some(ref val) = self.msg_rcpt { val.validate()? }
		Ok(())
	}
}


// DocumentLineIdentification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DocumentLineIdentification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<DocumentLineType1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nb", skip_serializing_if = "Option::is_none") )]
	pub nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdDt", skip_serializing_if = "Option::is_none") )]
	pub rltd_dt: Option<String>,
}

impl DocumentLineIdentification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "nb exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// DocumentLineInformation1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DocumentLineInformation1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: Vec<DocumentLineIdentification1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Desc", skip_serializing_if = "Option::is_none") )]
	pub desc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<RemittanceAmount3>,
}

impl DocumentLineInformation1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		for item in &self.id { item.validate()? }
		if let Some(ref val) = self.desc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "desc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 2048 {
				return Err(ValidationError::new(1002, "desc exceeds the maximum length of 2048".to_string()));
			}
		}
		if let Some(ref val) = self.amt { val.validate()? }
		Ok(())
	}
}


// DocumentLineInformation2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DocumentLineInformation2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: Vec<DocumentLineIdentification1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Desc", skip_serializing_if = "Option::is_none") )]
	pub desc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<RemittanceAmount4>,
}

impl DocumentLineInformation2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		for item in &self.id { item.validate()? }
		if let Some(ref val) = self.desc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "desc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 2048 {
				return Err(ValidationError::new(1002, "desc exceeds the maximum length of 2048".to_string()));
			}
		}
		if let Some(ref val) = self.amt { val.validate()? }
		Ok(())
	}
}


// DocumentLineType1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DocumentLineType1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdOrPrtry") )]
	pub cd_or_prtry: DocumentLineType1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issr", skip_serializing_if = "Option::is_none") )]
	pub issr: Option<String>,
}

impl DocumentLineType1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.cd_or_prtry.validate()?;
		if let Some(ref val) = self.issr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "issr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "issr exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// DocumentLineType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DocumentLineType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl DocumentLineType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// DocumentNumber5Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DocumentNumber5Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ShrtNb", skip_serializing_if = "Option::is_none") )]
	pub shrt_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LngNb", skip_serializing_if = "Option::is_none") )]
	pub lng_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtryNb", skip_serializing_if = "Option::is_none") )]
	pub prtry_nb: Option<GenericIdentification36>,
}

impl DocumentNumber5Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.shrt_nb {
			let pattern = Regex::new("[0-9]{3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "shrt_nb does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.lng_nb {
			let pattern = Regex::new("[a-z]{4}\\.[0-9]{3}\\.[0-9]{3}\\.[0-9]{2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "lng_nb does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.prtry_nb { val.validate()? }
		Ok(())
	}
}


// DocumentToSend4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DocumentToSend4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rcpt") )]
	pub rcpt: PartyIdentification125Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MtdOfTrnsmssn") )]
	pub mtd_of_trnsmssn: CommunicationMethod3Choice,
}

impl DocumentToSend4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.tp.chars().count() < 1 {
			return Err(ValidationError::new(1001, "tp is shorter than the minimum length of 1".to_string()));
		}
		if self.tp.chars().count() > 140 {
			return Err(ValidationError::new(1002, "tp exceeds the maximum length of 140".to_string()));
		}
		self.rcpt.validate()?;
		self.mtd_of_trnsmssn.validate()?;
		Ok(())
	}
}


// DocumentType1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DocumentType1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdOrPrtry") )]
	pub cd_or_prtry: DocumentType2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issr", skip_serializing_if = "Option::is_none") )]
	pub issr: Option<String>,
}

impl DocumentType1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.cd_or_prtry.validate()?;
		if let Some(ref val) = self.issr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "issr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "issr exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// DocumentType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DocumentType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification1>,
}

impl DocumentType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// DocumentType2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DocumentType2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl DocumentType2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// DocumentType3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum DocumentType3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "RADM") )]
	CodeRADM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RPIN") )]
	CodeRPIN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FXDR") )]
	CodeFXDR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DISP") )]
	CodeDISP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PUOR") )]
	CodePUOR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SCOR") )]
	CodeSCOR,
}

impl DocumentType3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// DocumentType6Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum DocumentType6Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "MSIN") )]
	CodeMSIN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CNFA") )]
	CodeCNFA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DNFA") )]
	CodeDNFA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CINV") )]
	CodeCINV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CREN") )]
	CodeCREN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DEBN") )]
	CodeDEBN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HIRI") )]
	CodeHIRI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SBIN") )]
	CodeSBIN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CMCN") )]
	CodeCMCN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SOAC") )]
	CodeSOAC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DISP") )]
	CodeDISP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BOLD") )]
	CodeBOLD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VCHR") )]
	CodeVCHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AROI") )]
	CodeAROI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TSUT") )]
	CodeTSUT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PUOR") )]
	CodePUOR,
}

impl DocumentType6Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// DueDate1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct DueDate1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DueDt", skip_serializing_if = "Option::is_none") )]
	pub due_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
}

impl DueDate1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// DurationType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum DurationType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "YEAR") )]
	CodeYEAR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WEEK") )]
	CodeWEEK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SEAS") )]
	CodeSEAS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QURT") )]
	CodeQURT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MNTH") )]
	CodeMNTH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MNUT") )]
	CodeMNUT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HOUR") )]
	CodeHOUR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DASD") )]
	CodeDASD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
}

impl DurationType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// EMTDataReportingVFMUKType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum EMTDataReportingVFMUKType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "YSCO") )]
	CodeYSCO,
}

impl EMTDataReportingVFMUKType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// EUCapitalGain2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum EUCapitalGain2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "EUSI") )]
	CodeEUSI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EUSO") )]
	CodeEUSO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UKWN") )]
	CodeUKWN,
}

impl EUCapitalGain2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// EUDividendStatus1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum EUDividendStatus1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "DIVI") )]
	CodeDIVI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DIVO") )]
	CodeDIVO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UKWN") )]
	CodeUKWN,
}

impl EUDividendStatus1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// EUSavingsDirective1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum EUSavingsDirective1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "EUSI") )]
	CodeEUSI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EUSO") )]
	CodeEUSO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VARI") )]
	CodeVARI,
}

impl EUSavingsDirective1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// EarlyPayment1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EarlyPayment1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "EarlyPmtDt") )]
	pub early_pmt_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DscntPct") )]
	pub dscnt_pct: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DscntAmt") )]
	pub dscnt_amt: CurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EarlyPmtTaxSpcfctn", skip_serializing_if = "Option::is_none") )]
	pub early_pmt_tax_spcfctn: Option<Vec<EarlyPaymentsVAT1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EarlyPmtTaxTtl", skip_serializing_if = "Option::is_none") )]
	pub early_pmt_tax_ttl: Option<CurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DuePyblAmtWthEarlyPmt", skip_serializing_if = "Option::is_none") )]
	pub due_pybl_amt_wth_early_pmt: Option<CurrencyAndAmount>,
}

impl EarlyPayment1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.dscnt_amt.validate()?;
		if let Some(ref vec) = self.early_pmt_tax_spcfctn { for item in vec { item.validate()? } }
		if let Some(ref val) = self.early_pmt_tax_ttl { val.validate()? }
		if let Some(ref val) = self.due_pybl_amt_wth_early_pmt { val.validate()? }
		Ok(())
	}
}


// EarlyPaymentsVAT1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EarlyPaymentsVAT1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxRate") )]
	pub tax_rate: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DscntTaxTp") )]
	pub dscnt_tax_tp: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DscntTaxAmt") )]
	pub dscnt_tax_amt: CurrencyAndAmount,
}

impl EarlyPaymentsVAT1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.dscnt_tax_tp.chars().count() < 1 {
			return Err(ValidationError::new(1001, "dscnt_tax_tp is shorter than the minimum length of 1".to_string()));
		}
		if self.dscnt_tax_tp.chars().count() > 4 {
			return Err(ValidationError::new(1002, "dscnt_tax_tp exceeds the maximum length of 4".to_string()));
		}
		self.dscnt_tax_amt.validate()?;
		Ok(())
	}
}


// EffectiveDate1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EffectiveDate1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FctvDt") )]
	pub fctv_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FctvDtParam", skip_serializing_if = "Option::is_none") )]
	pub fctv_dt_param: Option<String>,
}

impl EffectiveDate1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.fctv_dt_param {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "fctv_dt_param is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "fctv_dt_param exceeds the maximum length of 4".to_string()));
			}
		}
		Ok(())
	}
}


// ElectronicInvoice1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ElectronicInvoice1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PresntmntTp") )]
	pub presntmnt_tp: PresentmentType1Code,
}

impl ElectronicInvoice1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.presntmnt_tp.validate()?;
		Ok(())
	}
}


// Eligible1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum Eligible1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ELIG") )]
	CodeELIG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NELI") )]
	CodeNELI,
}

impl Eligible1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// EmbeddedType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum EmbeddedType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CANC") )]
	CodeCANC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EXTD") )]
	CodeEXTD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OPET") )]
	CodeOPET,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MDET") )]
	CodeMDET,
}

impl EmbeddedType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// EmissionAllowanceProductType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum EmissionAllowanceProductType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "EUAA") )]
	CodeEUAA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EUAE") )]
	CodeEUAE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ERUE") )]
	CodeERUE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CERE") )]
	CodeCERE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
}

impl EmissionAllowanceProductType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// EnabledStatusReason1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EnabledStatusReason1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd") )]
	pub cd: EnabledStatusReason2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
}

impl EnabledStatusReason1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.cd.validate()?;
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 350".to_string()));
			}
		}
		Ok(())
	}
}


// EnabledStatusReason1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EnabledStatusReason1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NoSpcfdRsn", skip_serializing_if = "Option::is_none") )]
	pub no_spcfd_rsn: Option<NoReasonCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<Vec<EnabledStatusReason1>>,
}

impl EnabledStatusReason1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.no_spcfd_rsn { val.validate()? }
		if let Some(ref vec) = self.rsn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// EnabledStatusReason1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum EnabledStatusReason1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "MODI") )]
	CodeMODI,
}

impl EnabledStatusReason1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// EnabledStatusReason2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EnabledStatusReason2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<EnabledStatusReason1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification36>,
}

impl EnabledStatusReason2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// EndOfDayRequirement1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EndOfDayRequirement1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitlMrgnRqrmnt", skip_serializing_if = "Option::is_none") )]
	pub initl_mrgn_rqrmnt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VartnMrgnRqrmnt", skip_serializing_if = "Option::is_none") )]
	pub vartn_mrgn_rqrmnt: Option<AmountAndDirection102>,
}

impl EndOfDayRequirement1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.initl_mrgn_rqrmnt { val.validate()? }
		if let Some(ref val) = self.vartn_mrgn_rqrmnt { val.validate()? }
		Ok(())
	}
}


// EndOfDayRequirement2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EndOfDayRequirement2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitlMrgnRqrmnts") )]
	pub initl_mrgn_rqrmnts: InitialMarginRequirement1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VartnMrgnRqrmnts") )]
	pub vartn_mrgn_rqrmnts: AmountAndDirection102,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MrgnAcctId") )]
	pub mrgn_acct_id: GenericIdentification165,
}

impl EndOfDayRequirement2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.initl_mrgn_rqrmnts.validate()?;
		self.vartn_mrgn_rqrmnts.validate()?;
		self.mrgn_acct_id.validate()?;
		Ok(())
	}
}


// EndPoint1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EndPoint1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfPmts", skip_serializing_if = "Option::is_none") )]
	pub nb_of_pmts: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LastPmtDt", skip_serializing_if = "Option::is_none") )]
	pub last_pmt_dt: Option<String>,
}

impl EndPoint1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nb_of_pmts {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nb_of_pmts is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "nb_of_pmts exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// EnergyCommodityCoal1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EnergyCommodityCoal1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType24Code,
}

impl EnergyCommodityCoal1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		Ok(())
	}
}


// EnergyCommodityCoal2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EnergyCommodityCoal2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType24Code>,
}

impl EnergyCommodityCoal2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// EnergyCommodityDistillates1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EnergyCommodityDistillates1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType25Code,
}

impl EnergyCommodityDistillates1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		Ok(())
	}
}


// EnergyCommodityDistillates2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EnergyCommodityDistillates2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType25Code>,
}

impl EnergyCommodityDistillates2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// EnergyCommodityElectricity1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EnergyCommodityElectricity1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType6Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlSubPdct") )]
	pub addtl_sub_pdct: AssetClassDetailedSubProductType5Code,
}

impl EnergyCommodityElectricity1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		self.addtl_sub_pdct.validate()?;
		Ok(())
	}
}


// EnergyCommodityElectricity2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EnergyCommodityElectricity2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType6Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlSubPdct", skip_serializing_if = "Option::is_none") )]
	pub addtl_sub_pdct: Option<AssetClassDetailedSubProductType5Code>,
}

impl EnergyCommodityElectricity2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		if let Some(ref val) = self.addtl_sub_pdct { val.validate()? }
		Ok(())
	}
}


// EnergyCommodityInterEnergy1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EnergyCommodityInterEnergy1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType26Code,
}

impl EnergyCommodityInterEnergy1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		Ok(())
	}
}


// EnergyCommodityInterEnergy2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EnergyCommodityInterEnergy2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType26Code>,
}

impl EnergyCommodityInterEnergy2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// EnergyCommodityLightEnd1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EnergyCommodityLightEnd1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType27Code,
}

impl EnergyCommodityLightEnd1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		Ok(())
	}
}


// EnergyCommodityLightEnd2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EnergyCommodityLightEnd2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType27Code>,
}

impl EnergyCommodityLightEnd2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// EnergyCommodityNaturalGas1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EnergyCommodityNaturalGas1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType7Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlSubPdct", skip_serializing_if = "Option::is_none") )]
	pub addtl_sub_pdct: Option<AssetClassDetailedSubProductType6Code>,
}

impl EnergyCommodityNaturalGas1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		if let Some(ref val) = self.addtl_sub_pdct { val.validate()? }
		Ok(())
	}
}


// EnergyCommodityNaturalGas2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EnergyCommodityNaturalGas2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType7Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlSubPdct") )]
	pub addtl_sub_pdct: AssetClassDetailedSubProductType31Code,
}

impl EnergyCommodityNaturalGas2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		self.addtl_sub_pdct.validate()?;
		Ok(())
	}
}


// EnergyCommodityNaturalGas3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EnergyCommodityNaturalGas3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType7Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlSubPdct", skip_serializing_if = "Option::is_none") )]
	pub addtl_sub_pdct: Option<AssetClassDetailedSubProductType31Code>,
}

impl EnergyCommodityNaturalGas3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		if let Some(ref val) = self.addtl_sub_pdct { val.validate()? }
		Ok(())
	}
}


// EnergyCommodityOil1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EnergyCommodityOil1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType8Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlSubPdct", skip_serializing_if = "Option::is_none") )]
	pub addtl_sub_pdct: Option<AssetClassDetailedSubProductType7Code>,
}

impl EnergyCommodityOil1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		if let Some(ref val) = self.addtl_sub_pdct { val.validate()? }
		Ok(())
	}
}


// EnergyCommodityOil2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EnergyCommodityOil2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType8Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlSubPdct") )]
	pub addtl_sub_pdct: AssetClassDetailedSubProductType32Code,
}

impl EnergyCommodityOil2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		self.addtl_sub_pdct.validate()?;
		Ok(())
	}
}


// EnergyCommodityOil3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EnergyCommodityOil3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType8Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlSubPdct", skip_serializing_if = "Option::is_none") )]
	pub addtl_sub_pdct: Option<AssetClassDetailedSubProductType32Code>,
}

impl EnergyCommodityOil3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		if let Some(ref val) = self.addtl_sub_pdct { val.validate()? }
		Ok(())
	}
}


// EnergyCommodityOther1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EnergyCommodityOther1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType49Code,
}

impl EnergyCommodityOther1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		Ok(())
	}
}


// EnergyCommodityOther2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EnergyCommodityOther2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType49Code>,
}

impl EnergyCommodityOther2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// EnergyCommodityRenewableEnergy1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EnergyCommodityRenewableEnergy1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType28Code,
}

impl EnergyCommodityRenewableEnergy1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		Ok(())
	}
}


// EnergyCommodityRenewableEnergy2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EnergyCommodityRenewableEnergy2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType28Code>,
}

impl EnergyCommodityRenewableEnergy2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// EnergyDeliveryAttribute10 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EnergyDeliveryAttribute10 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DlvryIntrvl", skip_serializing_if = "Option::is_none") )]
	pub dlvry_intrvl: Option<Vec<TimePeriodDetails1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DlvryDt", skip_serializing_if = "Option::is_none") )]
	pub dlvry_dt: Option<DatePeriod1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Drtn", skip_serializing_if = "Option::is_none") )]
	pub drtn: Option<DurationType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WkDay", skip_serializing_if = "Option::is_none") )]
	pub wk_day: Option<Vec<WeekDay3Code>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DlvryCpcty", skip_serializing_if = "Option::is_none") )]
	pub dlvry_cpcty: Option<Quantity47Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QtyUnit", skip_serializing_if = "Option::is_none") )]
	pub qty_unit: Option<EnergyQuantityUnit2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PricTmIntrvlQty", skip_serializing_if = "Option::is_none") )]
	pub pric_tm_intrvl_qty: Option<AmountAndDirection106>,
}

impl EnergyDeliveryAttribute10 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.dlvry_intrvl { for item in vec { item.validate()? } }
		if let Some(ref val) = self.dlvry_dt { val.validate()? }
		if let Some(ref val) = self.drtn { val.validate()? }
		if let Some(ref vec) = self.wk_day { for item in vec { item.validate()? } }
		if let Some(ref val) = self.dlvry_cpcty { val.validate()? }
		if let Some(ref val) = self.qty_unit { val.validate()? }
		if let Some(ref val) = self.pric_tm_intrvl_qty { val.validate()? }
		Ok(())
	}
}


// EnergyLoadType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum EnergyLoadType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "BSLD") )]
	CodeBSLD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GASD") )]
	CodeGASD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HABH") )]
	CodeHABH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OFFP") )]
	CodeOFFP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PKLD") )]
	CodePKLD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SHPD") )]
	CodeSHPD,
}

impl EnergyLoadType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// EnergyQuantityUnit2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EnergyQuantityUnit2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<EnergyQuantityUnit2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl EnergyQuantityUnit2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 52 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 52".to_string()));
			}
		}
		Ok(())
	}
}


// EnergyQuantityUnit2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum EnergyQuantityUnit2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "BTUD") )]
	CodeBTUD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CMPD") )]
	CodeCMPD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GJDD") )]
	CodeGJDD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GWAT") )]
	CodeGWAT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GWHD") )]
	CodeGWHD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GWHH") )]
	CodeGWHH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HMJD") )]
	CodeHMJD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "KTMD") )]
	CodeKTMD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "KWAT") )]
	CodeKWAT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "KWHD") )]
	CodeKWHD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "KWHH") )]
	CodeKWHH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MCMD") )]
	CodeMCMD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MJDD") )]
	CodeMJDD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MBTD") )]
	CodeMBTD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MMJD") )]
	CodeMMJD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MTMD") )]
	CodeMTMD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MWAT") )]
	CodeMWAT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MWHD") )]
	CodeMWHD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MWHH") )]
	CodeMWHH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "THMD") )]
	CodeTHMD,
}

impl EnergyQuantityUnit2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// EnergySpecificAttribute9 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EnergySpecificAttribute9 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DlvryPtOrZone", skip_serializing_if = "Option::is_none") )]
	pub dlvry_pt_or_zone: Option<Vec<DeliveryInterconnectionPoint1Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrCnnctnPt", skip_serializing_if = "Option::is_none") )]
	pub intr_cnnctn_pt: Option<DeliveryInterconnectionPoint1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LdTp", skip_serializing_if = "Option::is_none") )]
	pub ld_tp: Option<EnergyLoadType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DlvryAttr", skip_serializing_if = "Option::is_none") )]
	pub dlvry_attr: Option<Vec<EnergyDeliveryAttribute10>>,
}

impl EnergySpecificAttribute9 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.dlvry_pt_or_zone { for item in vec { item.validate()? } }
		if let Some(ref val) = self.intr_cnnctn_pt { val.validate()? }
		if let Some(ref val) = self.ld_tp { val.validate()? }
		if let Some(ref vec) = self.dlvry_attr { for item in vec { item.validate()? } }
		Ok(())
	}
}


// EnrolmentHeader3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EnrolmentHeader3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm") )]
	pub cre_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgOrgtr", skip_serializing_if = "Option::is_none") )]
	pub msg_orgtr: Option<RTPPartyIdentification2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgRcpt", skip_serializing_if = "Option::is_none") )]
	pub msg_rcpt: Option<RTPPartyIdentification2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitgPty") )]
	pub initg_pty: RTPPartyIdentification2,
}

impl EnrolmentHeader3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.msg_orgtr { val.validate()? }
		if let Some(ref val) = self.msg_rcpt { val.validate()? }
		self.initg_pty.validate()?;
		Ok(())
	}
}


// EnrolmentStatus3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EnrolmentStatus3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlBizInstr", skip_serializing_if = "Option::is_none") )]
	pub orgnl_biz_instr: Option<OriginalBusinessInstruction1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts") )]
	pub sts: ServiceStatus1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsRsn", skip_serializing_if = "Option::is_none") )]
	pub sts_rsn: Option<CreditorEnrolmentStatusReason3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlEnrlmntRef", skip_serializing_if = "Option::is_none") )]
	pub orgnl_enrlmnt_ref: Option<OriginalEnrolment3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FctvEnrlmntDt", skip_serializing_if = "Option::is_none") )]
	pub fctv_enrlmnt_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl EnrolmentStatus3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgnl_biz_instr { val.validate()? }
		self.sts.validate()?;
		if let Some(ref val) = self.sts_rsn { val.validate()? }
		if let Some(ref val) = self.orgnl_enrlmnt_ref { val.validate()? }
		if let Some(ref val) = self.fctv_enrlmnt_dt { val.validate()? }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// Entry2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum Entry2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "TRIA") )]
	CodeTRIA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OFFI") )]
	CodeOFFI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REQU") )]
	CodeREQU,
}

impl Entry2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// EntryDetails13 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EntryDetails13 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Btch", skip_serializing_if = "Option::is_none") )]
	pub btch: Option<BatchInformation2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxDtls", skip_serializing_if = "Option::is_none") )]
	pub tx_dtls: Option<Vec<EntryTransaction14>>,
}

impl EntryDetails13 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.btch { val.validate()? }
		if let Some(ref vec) = self.tx_dtls { for item in vec { item.validate()? } }
		Ok(())
	}
}


// EntryStatus1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EntryStatus1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl EntryStatus1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// EntryStatus1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum EntryStatus1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "BOOK") )]
	CodeBOOK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PDNG") )]
	CodePDNG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FUTR") )]
	CodeFUTR,
}

impl EntryStatus1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// EntryTransaction14 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EntryTransaction14 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Refs", skip_serializing_if = "Option::is_none") )]
	pub refs: Option<TransactionReferences6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbtInd", skip_serializing_if = "Option::is_none") )]
	pub cdt_dbt_ind: Option<CreditDebitCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AmtDtls", skip_serializing_if = "Option::is_none") )]
	pub amt_dtls: Option<AmountAndCurrencyExchange4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Avlbty", skip_serializing_if = "Option::is_none") )]
	pub avlbty: Option<Vec<CashAvailability1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BkTxCd", skip_serializing_if = "Option::is_none") )]
	pub bk_tx_cd: Option<BankTransactionCodeStructure4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Chrgs", skip_serializing_if = "Option::is_none") )]
	pub chrgs: Option<Charges15>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Intrst", skip_serializing_if = "Option::is_none") )]
	pub intrst: Option<TransactionInterest4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdPties", skip_serializing_if = "Option::is_none") )]
	pub rltd_pties: Option<TransactionParties12>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdAgts", skip_serializing_if = "Option::is_none") )]
	pub rltd_agts: Option<TransactionAgents6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LclInstrm", skip_serializing_if = "Option::is_none") )]
	pub lcl_instrm: Option<LocalInstrument2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtTpInf", skip_serializing_if = "Option::is_none") )]
	pub pmt_tp_inf: Option<PaymentTypeInformation27>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Purp", skip_serializing_if = "Option::is_none") )]
	pub purp: Option<Purpose2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdRmtInf", skip_serializing_if = "Option::is_none") )]
	pub rltd_rmt_inf: Option<Vec<RemittanceLocation8>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RmtInf", skip_serializing_if = "Option::is_none") )]
	pub rmt_inf: Option<RemittanceInformation22>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdDts", skip_serializing_if = "Option::is_none") )]
	pub rltd_dts: Option<TransactionDates3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdPric", skip_serializing_if = "Option::is_none") )]
	pub rltd_pric: Option<TransactionPrice4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdQties", skip_serializing_if = "Option::is_none") )]
	pub rltd_qties: Option<Vec<TransactionQuantities3Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmId", skip_serializing_if = "Option::is_none") )]
	pub fin_instrm_id: Option<SecurityIdentification19>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tax", skip_serializing_if = "Option::is_none") )]
	pub tax: Option<TaxData1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RtrInf", skip_serializing_if = "Option::is_none") )]
	pub rtr_inf: Option<PaymentReturnReason8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CorpActn", skip_serializing_if = "Option::is_none") )]
	pub corp_actn: Option<CorporateAction9>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SfkpgAcct", skip_serializing_if = "Option::is_none") )]
	pub sfkpg_acct: Option<SecuritiesAccount19>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshDpst", skip_serializing_if = "Option::is_none") )]
	pub csh_dpst: Option<Vec<CashDeposit1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CardTx", skip_serializing_if = "Option::is_none") )]
	pub card_tx: Option<CardTransaction18>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlTxInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_tx_inf: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl EntryTransaction14 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.refs { val.validate()? }
		if let Some(ref val) = self.amt { val.validate()? }
		if let Some(ref val) = self.cdt_dbt_ind { val.validate()? }
		if let Some(ref val) = self.amt_dtls { val.validate()? }
		if let Some(ref vec) = self.avlbty { for item in vec { item.validate()? } }
		if let Some(ref val) = self.bk_tx_cd { val.validate()? }
		if let Some(ref val) = self.chrgs { val.validate()? }
		if let Some(ref val) = self.intrst { val.validate()? }
		if let Some(ref val) = self.rltd_pties { val.validate()? }
		if let Some(ref val) = self.rltd_agts { val.validate()? }
		if let Some(ref val) = self.lcl_instrm { val.validate()? }
		if let Some(ref val) = self.pmt_tp_inf { val.validate()? }
		if let Some(ref val) = self.purp { val.validate()? }
		if let Some(ref vec) = self.rltd_rmt_inf { for item in vec { item.validate()? } }
		if let Some(ref val) = self.rmt_inf { val.validate()? }
		if let Some(ref val) = self.rltd_dts { val.validate()? }
		if let Some(ref val) = self.rltd_pric { val.validate()? }
		if let Some(ref vec) = self.rltd_qties { for item in vec { item.validate()? } }
		if let Some(ref val) = self.fin_instrm_id { val.validate()? }
		if let Some(ref val) = self.tax { val.validate()? }
		if let Some(ref val) = self.rtr_inf { val.validate()? }
		if let Some(ref val) = self.corp_actn { val.validate()? }
		if let Some(ref val) = self.sfkpg_acct { val.validate()? }
		if let Some(ref vec) = self.csh_dpst { for item in vec { item.validate()? } }
		if let Some(ref val) = self.card_tx { val.validate()? }
		if let Some(ref val) = self.addtl_tx_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_tx_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 500 {
				return Err(ValidationError::new(1002, "addtl_tx_inf exceeds the maximum length of 500".to_string()));
			}
		}
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// EnvironmentCommodityOther1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EnvironmentCommodityOther1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType3Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType49Code,
}

impl EnvironmentCommodityOther1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		Ok(())
	}
}


// EnvironmentCommodityOther2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EnvironmentCommodityOther2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType3Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType49Code>,
}

impl EnvironmentCommodityOther2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// EnvironmentalCommodityCarbonRelated1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EnvironmentalCommodityCarbonRelated1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType3Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType29Code,
}

impl EnvironmentalCommodityCarbonRelated1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		Ok(())
	}
}


// EnvironmentalCommodityCarbonRelated2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EnvironmentalCommodityCarbonRelated2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType3Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType29Code>,
}

impl EnvironmentalCommodityCarbonRelated2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// EnvironmentalCommodityEmission1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EnvironmentalCommodityEmission1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType3Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType10Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlSubPdct", skip_serializing_if = "Option::is_none") )]
	pub addtl_sub_pdct: Option<AssetClassDetailedSubProductType8Code>,
}

impl EnvironmentalCommodityEmission1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		if let Some(ref val) = self.addtl_sub_pdct { val.validate()? }
		Ok(())
	}
}


// EnvironmentalCommodityEmission2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EnvironmentalCommodityEmission2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType3Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType10Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlSubPdct") )]
	pub addtl_sub_pdct: AssetClassDetailedSubProductType8Code,
}

impl EnvironmentalCommodityEmission2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		self.addtl_sub_pdct.validate()?;
		Ok(())
	}
}


// EnvironmentalCommodityEmission3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EnvironmentalCommodityEmission3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType3Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType10Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlSubPdct", skip_serializing_if = "Option::is_none") )]
	pub addtl_sub_pdct: Option<AssetClassDetailedSubProductType8Code>,
}

impl EnvironmentalCommodityEmission3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		if let Some(ref val) = self.addtl_sub_pdct { val.validate()? }
		Ok(())
	}
}


// EnvironmentalCommodityWeather1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EnvironmentalCommodityWeather1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType3Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType30Code,
}

impl EnvironmentalCommodityWeather1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		Ok(())
	}
}


// EnvironmentalCommodityWeather2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EnvironmentalCommodityWeather2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType3Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType30Code>,
}

impl EnvironmentalCommodityWeather2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// Equity3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Equity3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrefToIncm") )]
	pub pref_to_incm: PreferenceToIncome5Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MtrtyDt", skip_serializing_if = "Option::is_none") )]
	pub mtrty_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NonPdAmt", skip_serializing_if = "Option::is_none") )]
	pub non_pd_amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ParVal", skip_serializing_if = "Option::is_none") )]
	pub par_val: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VtngRghtsPerShr", skip_serializing_if = "Option::is_none") )]
	pub vtng_rghts_per_shr: Option<f64>,
}

impl Equity3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pref_to_incm.validate()?;
		if let Some(ref val) = self.non_pd_amt { val.validate()? }
		if let Some(ref val) = self.par_val { val.validate()? }
		Ok(())
	}
}


// EquityDerivative2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EquityDerivative2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "UndrlygTp") )]
	pub undrlyg_tp: EquityDerivative3Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Param", skip_serializing_if = "Option::is_none") )]
	pub param: Option<EquityReturnParameter1Code>,
}

impl EquityDerivative2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.undrlyg_tp.validate()?;
		if let Some(ref val) = self.param { val.validate()? }
		Ok(())
	}
}


// EquityDerivative3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EquityDerivative3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Bskt", skip_serializing_if = "Option::is_none") )]
	pub bskt: Option<UnderlyingEquityType3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Indx", skip_serializing_if = "Option::is_none") )]
	pub indx: Option<UnderlyingEquityType4Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SnglNm", skip_serializing_if = "Option::is_none") )]
	pub sngl_nm: Option<UnderlyingEquityType5Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<UnderlyingEquityType6Code>,
}

impl EquityDerivative3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.bskt { val.validate()? }
		if let Some(ref val) = self.indx { val.validate()? }
		if let Some(ref val) = self.sngl_nm { val.validate()? }
		if let Some(ref val) = self.othr { val.validate()? }
		Ok(())
	}
}


// EquityInstrumentReportingClassification1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum EquityInstrumentReportingClassification1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "SHRS") )]
	CodeSHRS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ETFS") )]
	CodeETFS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DPRS") )]
	CodeDPRS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CRFT") )]
	CodeCRFT,
}

impl EquityInstrumentReportingClassification1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// EquityReturnParameter1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum EquityReturnParameter1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRDV") )]
	CodePRDV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRVA") )]
	CodePRVA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRVO") )]
	CodePRVO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRBP") )]
	CodePRBP,
}

impl EquityReturnParameter1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// EquivalentAmount2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EquivalentAmount2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveOrHistoricCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CcyOfTrf") )]
	pub ccy_of_trf: String,
}

impl EquivalentAmount2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.amt.validate()?;
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.ccy_of_trf) {
			return Err(ValidationError::new(1005, "ccy_of_trf does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// ErrorHandling1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ErrorHandling1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<ErrorHandling1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl ErrorHandling1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 4".to_string()));
			}
			let pattern = Regex::new("[a-zA-Z0-9]{1,4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "prtry does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// ErrorHandling1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ErrorHandling1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "X020") )]
	CodeX020,
	#[cfg_attr( feature = "derive_serde", serde(rename = "X030") )]
	CodeX030,
	#[cfg_attr( feature = "derive_serde", serde(rename = "X050") )]
	CodeX050,
}

impl ErrorHandling1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ErrorHandling2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ErrorHandling2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<ErrorHandling1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl ErrorHandling2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// ErrorHandling3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ErrorHandling3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Err") )]
	pub err: ErrorHandling1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Desc", skip_serializing_if = "Option::is_none") )]
	pub desc: Option<String>,
}

impl ErrorHandling3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.err.validate()?;
		if let Some(ref val) = self.desc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "desc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "desc exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// ErrorHandling3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ErrorHandling3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl ErrorHandling3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// ErrorHandling4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ErrorHandling4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Err") )]
	pub err: ErrorHandling2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Desc", skip_serializing_if = "Option::is_none") )]
	pub desc: Option<String>,
}

impl ErrorHandling4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.err.validate()?;
		if let Some(ref val) = self.desc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "desc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "desc exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// ErrorHandling5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ErrorHandling5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Err") )]
	pub err: ErrorHandling3Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Desc", skip_serializing_if = "Option::is_none") )]
	pub desc: Option<String>,
}

impl ErrorHandling5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.err.validate()?;
		if let Some(ref val) = self.desc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "desc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "desc exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// EstimatedFundCashForecast5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EstimatedFundCashForecast5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradDtTm") )]
	pub trad_dt_tm: DateAndDateTimeChoice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsTradDtTm", skip_serializing_if = "Option::is_none") )]
	pub prvs_trad_dt_tm: Option<DateAndDateTimeChoice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmDtls") )]
	pub fin_instrm_dtls: FinancialInstrument9,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EstmtdTtlNAV", skip_serializing_if = "Option::is_none") )]
	pub estmtd_ttl_nav: Option<Vec<ActiveOrHistoricCurrencyAndAmount>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsTtlNAV", skip_serializing_if = "Option::is_none") )]
	pub prvs_ttl_nav: Option<Vec<ActiveOrHistoricCurrencyAndAmount>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EstmtdTtlUnitsNb", skip_serializing_if = "Option::is_none") )]
	pub estmtd_ttl_units_nb: Option<FinancialInstrumentQuantity1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsTtlUnitsNb", skip_serializing_if = "Option::is_none") )]
	pub prvs_ttl_units_nb: Option<FinancialInstrumentQuantity1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EstmtdTtlNAVChngRate", skip_serializing_if = "Option::is_none") )]
	pub estmtd_ttl_nav_chng_rate: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstmtCcy", skip_serializing_if = "Option::is_none") )]
	pub invstmt_ccy: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CcySts", skip_serializing_if = "Option::is_none") )]
	pub ccy_sts: Option<CurrencyDesignation1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XcptnlNetCshFlowInd") )]
	pub xcptnl_net_csh_flow_ind: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pric", skip_serializing_if = "Option::is_none") )]
	pub pric: Option<UnitPrice19>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FXRate", skip_serializing_if = "Option::is_none") )]
	pub fx_rate: Option<ForeignExchangeTerms19>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EstmtdPctgOfShrClssTtlNAV", skip_serializing_if = "Option::is_none") )]
	pub estmtd_pctg_of_shr_clss_ttl_nav: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BrkdwnByPty", skip_serializing_if = "Option::is_none") )]
	pub brkdwn_by_pty: Option<Vec<BreakdownByParty3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BrkdwnByCtry", skip_serializing_if = "Option::is_none") )]
	pub brkdwn_by_ctry: Option<Vec<BreakdownByCountry2>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BrkdwnByCcy", skip_serializing_if = "Option::is_none") )]
	pub brkdwn_by_ccy: Option<Vec<BreakdownByCurrency2>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BrkdwnByUsrDfndParam", skip_serializing_if = "Option::is_none") )]
	pub brkdwn_by_usr_dfnd_param: Option<Vec<BreakdownByUserDefinedParameter3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EstmtdNetCshFcstDtls", skip_serializing_if = "Option::is_none") )]
	pub estmtd_net_csh_fcst_dtls: Option<Vec<NetCashForecast4>>,
}

impl EstimatedFundCashForecast5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		self.trad_dt_tm.validate()?;
		if let Some(ref val) = self.prvs_trad_dt_tm { val.validate()? }
		self.fin_instrm_dtls.validate()?;
		if let Some(ref vec) = self.estmtd_ttl_nav { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.prvs_ttl_nav { for item in vec { item.validate()? } }
		if let Some(ref val) = self.estmtd_ttl_units_nb { val.validate()? }
		if let Some(ref val) = self.prvs_ttl_units_nb { val.validate()? }
		if let Some(ref vec) = self.invstmt_ccy {
			for item in vec {
				let pattern = Regex::new("[A-Z]{3,3}").unwrap();
				if !pattern.is_match(&item) {
					return Err(ValidationError::new(1005, "invstmt_ccy does not match the required pattern".to_string()));
				}
			}
		}
		if let Some(ref val) = self.ccy_sts { val.validate()? }
		if let Some(ref val) = self.pric { val.validate()? }
		if let Some(ref val) = self.fx_rate { val.validate()? }
		if let Some(ref vec) = self.brkdwn_by_pty { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.brkdwn_by_ctry { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.brkdwn_by_ccy { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.brkdwn_by_usr_dfnd_param { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.estmtd_net_csh_fcst_dtls { for item in vec { item.validate()? } }
		Ok(())
	}
}


// EstimatedFundCashForecast6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EstimatedFundCashForecast6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradDtTm") )]
	pub trad_dt_tm: DateAndDateTimeChoice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsTradDtTm", skip_serializing_if = "Option::is_none") )]
	pub prvs_trad_dt_tm: Option<DateAndDateTimeChoice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmDtls") )]
	pub fin_instrm_dtls: FinancialInstrument9,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EstmtdTtlNAV", skip_serializing_if = "Option::is_none") )]
	pub estmtd_ttl_nav: Option<Vec<ActiveOrHistoricCurrencyAndAmount>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsTtlNAV", skip_serializing_if = "Option::is_none") )]
	pub prvs_ttl_nav: Option<Vec<ActiveOrHistoricCurrencyAndAmount>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EstmtdTtlUnitsNb", skip_serializing_if = "Option::is_none") )]
	pub estmtd_ttl_units_nb: Option<FinancialInstrumentQuantity1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsTtlUnitsNb", skip_serializing_if = "Option::is_none") )]
	pub prvs_ttl_units_nb: Option<FinancialInstrumentQuantity1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EstmtdTtlNAVChngRate", skip_serializing_if = "Option::is_none") )]
	pub estmtd_ttl_nav_chng_rate: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstmtCcy", skip_serializing_if = "Option::is_none") )]
	pub invstmt_ccy: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CcySts", skip_serializing_if = "Option::is_none") )]
	pub ccy_sts: Option<CurrencyDesignation1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XcptnlNetCshFlowInd") )]
	pub xcptnl_net_csh_flow_ind: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pric", skip_serializing_if = "Option::is_none") )]
	pub pric: Option<UnitPrice19>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FXRate", skip_serializing_if = "Option::is_none") )]
	pub fx_rate: Option<ForeignExchangeTerms19>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EstmtdPctgOfShrClssTtlNAV", skip_serializing_if = "Option::is_none") )]
	pub estmtd_pctg_of_shr_clss_ttl_nav: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EstmtdCshInFcstDtls", skip_serializing_if = "Option::is_none") )]
	pub estmtd_csh_in_fcst_dtls: Option<Vec<CashInForecast6>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EstmtdCshOutFcstDtls", skip_serializing_if = "Option::is_none") )]
	pub estmtd_csh_out_fcst_dtls: Option<Vec<CashOutForecast6>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EstmtdNetCshFcstDtls", skip_serializing_if = "Option::is_none") )]
	pub estmtd_net_csh_fcst_dtls: Option<Vec<NetCashForecast4>>,
}

impl EstimatedFundCashForecast6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		self.trad_dt_tm.validate()?;
		if let Some(ref val) = self.prvs_trad_dt_tm { val.validate()? }
		self.fin_instrm_dtls.validate()?;
		if let Some(ref vec) = self.estmtd_ttl_nav { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.prvs_ttl_nav { for item in vec { item.validate()? } }
		if let Some(ref val) = self.estmtd_ttl_units_nb { val.validate()? }
		if let Some(ref val) = self.prvs_ttl_units_nb { val.validate()? }
		if let Some(ref vec) = self.invstmt_ccy {
			for item in vec {
				let pattern = Regex::new("[A-Z]{3,3}").unwrap();
				if !pattern.is_match(&item) {
					return Err(ValidationError::new(1005, "invstmt_ccy does not match the required pattern".to_string()));
				}
			}
		}
		if let Some(ref val) = self.ccy_sts { val.validate()? }
		if let Some(ref val) = self.pric { val.validate()? }
		if let Some(ref val) = self.fx_rate { val.validate()? }
		if let Some(ref vec) = self.estmtd_csh_in_fcst_dtls { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.estmtd_csh_out_fcst_dtls { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.estmtd_net_csh_fcst_dtls { for item in vec { item.validate()? } }
		Ok(())
	}
}


// Event1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Event1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "EvtCd") )]
	pub evt_cd: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EvtParam", skip_serializing_if = "Option::is_none") )]
	pub evt_param: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EvtDesc", skip_serializing_if = "Option::is_none") )]
	pub evt_desc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EvtTm", skip_serializing_if = "Option::is_none") )]
	pub evt_tm: Option<String>,
}

impl Event1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.evt_cd.chars().count() < 1 {
			return Err(ValidationError::new(1001, "evt_cd is shorter than the minimum length of 1".to_string()));
		}
		if self.evt_cd.chars().count() > 4 {
			return Err(ValidationError::new(1002, "evt_cd exceeds the maximum length of 4".to_string()));
		}
		let pattern = Regex::new("[a-zA-Z0-9]{1,4}").unwrap();
		if !pattern.is_match(&self.evt_cd) {
			return Err(ValidationError::new(1005, "evt_cd does not match the required pattern".to_string()));
		}
		if let Some(ref vec) = self.evt_param {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "evt_param is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 35 {
					return Err(ValidationError::new(1002, "evt_param exceeds the maximum length of 35".to_string()));
				}
			}
		}
		if let Some(ref val) = self.evt_desc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "evt_desc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "evt_desc exceeds the maximum length of 350".to_string()));
			}
		}
		Ok(())
	}
}


// Event2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Event2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "EvtCd") )]
	pub evt_cd: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EvtParam", skip_serializing_if = "Option::is_none") )]
	pub evt_param: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EvtDesc", skip_serializing_if = "Option::is_none") )]
	pub evt_desc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EvtTm", skip_serializing_if = "Option::is_none") )]
	pub evt_tm: Option<String>,
}

impl Event2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.evt_cd.chars().count() < 1 {
			return Err(ValidationError::new(1001, "evt_cd is shorter than the minimum length of 1".to_string()));
		}
		if self.evt_cd.chars().count() > 4 {
			return Err(ValidationError::new(1002, "evt_cd exceeds the maximum length of 4".to_string()));
		}
		let pattern = Regex::new("[a-zA-Z0-9]{1,4}").unwrap();
		if !pattern.is_match(&self.evt_cd) {
			return Err(ValidationError::new(1005, "evt_cd does not match the required pattern".to_string()));
		}
		if let Some(ref vec) = self.evt_param {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "evt_param is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 35 {
					return Err(ValidationError::new(1002, "evt_param exceeds the maximum length of 35".to_string()));
				}
			}
		}
		if let Some(ref val) = self.evt_desc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "evt_desc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 1000 {
				return Err(ValidationError::new(1002, "evt_desc exceeds the maximum length of 1000".to_string()));
			}
		}
		Ok(())
	}
}


// EventFrequency10Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum EventFrequency10Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "DAIL") )]
	CodeDAIL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ADHO") )]
	CodeADHO,
}

impl EventFrequency10Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// EventFrequency1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum EventFrequency1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "YEAR") )]
	CodeYEAR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SEMI") )]
	CodeSEMI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QUTR") )]
	CodeQUTR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TOMN") )]
	CodeTOMN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MNTH") )]
	CodeMNTH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TWMN") )]
	CodeTWMN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TOWK") )]
	CodeTOWK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WEEK") )]
	CodeWEEK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DAIL") )]
	CodeDAIL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ADHO") )]
	CodeADHO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INDA") )]
	CodeINDA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OVNG") )]
	CodeOVNG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ONDE") )]
	CodeONDE,
}

impl EventFrequency1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// EventFrequency5Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum EventFrequency5Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "YEAR") )]
	CodeYEAR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SEMI") )]
	CodeSEMI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QUTR") )]
	CodeQUTR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MNTH") )]
	CodeMNTH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WEEK") )]
	CodeWEEK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DAIL") )]
	CodeDAIL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CLOS") )]
	CodeCLOS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TOMN") )]
	CodeTOMN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TOWK") )]
	CodeTOWK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TWMN") )]
	CodeTWMN,
}

impl EventFrequency5Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// EventFrequency7Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum EventFrequency7Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "YEAR") )]
	CodeYEAR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ADHO") )]
	CodeADHO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MNTH") )]
	CodeMNTH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DAIL") )]
	CodeDAIL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INDA") )]
	CodeINDA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WEEK") )]
	CodeWEEK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SEMI") )]
	CodeSEMI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QUTR") )]
	CodeQUTR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TOMN") )]
	CodeTOMN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TOWK") )]
	CodeTOWK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TWMN") )]
	CodeTWMN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OVNG") )]
	CodeOVNG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ONDE") )]
	CodeONDE,
}

impl EventFrequency7Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// EventFrequency8Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum EventFrequency8Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ADHO") )]
	CodeADHO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "YEAR") )]
	CodeYEAR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DAIL") )]
	CodeDAIL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FOMN") )]
	CodeFOMN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TOMN") )]
	CodeTOMN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TOWK") )]
	CodeTOWK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TYEA") )]
	CodeTYEA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INDA") )]
	CodeINDA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MNTH") )]
	CodeMNTH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ONDE") )]
	CodeONDE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OVNG") )]
	CodeOVNG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QUTR") )]
	CodeQUTR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SEMI") )]
	CodeSEMI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TWMN") )]
	CodeTWMN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WEEK") )]
	CodeWEEK,
}

impl EventFrequency8Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// EventFrequency9Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum EventFrequency9Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "YEAR") )]
	CodeYEAR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SEMI") )]
	CodeSEMI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QUTR") )]
	CodeQUTR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TOMN") )]
	CodeTOMN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MNTH") )]
	CodeMNTH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TWMN") )]
	CodeTWMN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TOWK") )]
	CodeTOWK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WEEK") )]
	CodeWEEK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DAIL") )]
	CodeDAIL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ADHO") )]
	CodeADHO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INDA") )]
	CodeINDA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OVNG") )]
	CodeOVNG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ONDE") )]
	CodeONDE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NONE") )]
	CodeNONE,
}

impl EventFrequency9Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// EventIdentifier1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EventIdentifier1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "EvtIdr", skip_serializing_if = "Option::is_none") )]
	pub evt_idr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstTradRskRdctnIdr", skip_serializing_if = "Option::is_none") )]
	pub pst_trad_rsk_rdctn_idr: Option<PostTradeRiskReductionIdentifier1>,
}

impl EventIdentifier1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.evt_idr {
			let pattern = Regex::new("[A-Z0-9]{18}[0-9]{2}[A-Z0-9]{0,32}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "evt_idr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.pst_trad_rsk_rdctn_idr { val.validate()? }
		Ok(())
	}
}


// EventType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct EventType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl EventType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// ExPostCostCalculationBasis1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ExPostCostCalculationBasis1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<ExPostCostCalculationBasis1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl ExPostCostCalculationBasis1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// ExPostCostCalculationBasis1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ExPostCostCalculationBasis1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "FIXB") )]
	CodeFIXB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ROLL") )]
	CodeROLL,
}

impl ExPostCostCalculationBasis1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ExchangeRate1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ExchangeRate1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnitCcy", skip_serializing_if = "Option::is_none") )]
	pub unit_ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XchgRate", skip_serializing_if = "Option::is_none") )]
	pub xchg_rate: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RateTp", skip_serializing_if = "Option::is_none") )]
	pub rate_tp: Option<ExchangeRateType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctId", skip_serializing_if = "Option::is_none") )]
	pub ctrct_id: Option<String>,
}

impl ExchangeRate1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.unit_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "unit_ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.rate_tp { val.validate()? }
		if let Some(ref val) = self.ctrct_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ctrct_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "ctrct_id exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// ExchangeRateBasis1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ExchangeRateBasis1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BaseCcy") )]
	pub base_ccy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QtdCcy") )]
	pub qtd_ccy: String,
}

impl ExchangeRateBasis1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.base_ccy) {
			return Err(ValidationError::new(1005, "base_ccy does not match the required pattern".to_string()));
		}
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.qtd_ccy) {
			return Err(ValidationError::new(1005, "qtd_ccy does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// ExchangeRateBasis1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ExchangeRateBasis1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CcyPair", skip_serializing_if = "Option::is_none") )]
	pub ccy_pair: Option<ExchangeRateBasis1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl ExchangeRateBasis1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ccy_pair { val.validate()? }
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 52 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 52".to_string()));
			}
		}
		Ok(())
	}
}


// ExchangeRateInformation1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ExchangeRateInformation1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "XchgRate", skip_serializing_if = "Option::is_none") )]
	pub xchg_rate: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RateTp", skip_serializing_if = "Option::is_none") )]
	pub rate_tp: Option<ExchangeRateType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctId", skip_serializing_if = "Option::is_none") )]
	pub ctrct_id: Option<String>,
}

impl ExchangeRateInformation1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rate_tp { val.validate()? }
		if let Some(ref val) = self.ctrct_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ctrct_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "ctrct_id exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// ExchangeRateOrPercentage1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ExchangeRateOrPercentage1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rate", skip_serializing_if = "Option::is_none") )]
	pub rate: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pctg", skip_serializing_if = "Option::is_none") )]
	pub pctg: Option<f64>,
}

impl ExchangeRateOrPercentage1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ExchangeRateReportOrError3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ExchangeRateReportOrError3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CcyXchgRpt", skip_serializing_if = "Option::is_none") )]
	pub ccy_xchg_rpt: Option<Vec<CurrencyExchangeReport4>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OprlErr", skip_serializing_if = "Option::is_none") )]
	pub oprl_err: Option<Vec<ErrorHandling3>>,
}

impl ExchangeRateReportOrError3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.ccy_xchg_rpt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.oprl_err { for item in vec { item.validate()? } }
		Ok(())
	}
}


// ExchangeRateReportOrError4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ExchangeRateReportOrError4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizErr", skip_serializing_if = "Option::is_none") )]
	pub biz_err: Option<Vec<ErrorHandling3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CcyXchg", skip_serializing_if = "Option::is_none") )]
	pub ccy_xchg: Option<CurrencyExchange20>,
}

impl ExchangeRateReportOrError4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.biz_err { for item in vec { item.validate()? } }
		if let Some(ref val) = self.ccy_xchg { val.validate()? }
		Ok(())
	}
}


// ExchangeRateType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ExchangeRateType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "SPOT") )]
	CodeSPOT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SALE") )]
	CodeSALE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AGRD") )]
	CodeAGRD,
}

impl ExchangeRateType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ExecutingParty1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ExecutingParty1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prsn", skip_serializing_if = "Option::is_none") )]
	pub prsn: Option<PersonIdentification12>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Algo", skip_serializing_if = "Option::is_none") )]
	pub algo: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Clnt", skip_serializing_if = "Option::is_none") )]
	pub clnt: Option<NoReasonCode>,
}

impl ExecutingParty1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.prsn { val.validate()? }
		if let Some(ref val) = self.algo {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "algo is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 50 {
				return Err(ValidationError::new(1002, "algo exceeds the maximum length of 50".to_string()));
			}
		}
		if let Some(ref val) = self.clnt { val.validate()? }
		Ok(())
	}
}


// ExecutingParty2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ExecutingParty2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prsn", skip_serializing_if = "Option::is_none") )]
	pub prsn: Option<GenericPersonIdentification1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Algo", skip_serializing_if = "Option::is_none") )]
	pub algo: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Clnt", skip_serializing_if = "Option::is_none") )]
	pub clnt: Option<NoReasonCode>,
}

impl ExecutingParty2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.prsn { val.validate()? }
		if let Some(ref val) = self.algo {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "algo is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 50 {
				return Err(ValidationError::new(1002, "algo exceeds the maximum length of 50".to_string()));
			}
		}
		if let Some(ref val) = self.clnt { val.validate()? }
		Ok(())
	}
}


// ExecutionType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ExecutionType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tm", skip_serializing_if = "Option::is_none") )]
	pub tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Evt", skip_serializing_if = "Option::is_none") )]
	pub evt: Option<EventType1Choice>,
}

impl ExecutionType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.evt { val.validate()? }
		Ok(())
	}
}


// ExerciseDate1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ExerciseDate1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrstExrcDt", skip_serializing_if = "Option::is_none") )]
	pub frst_exrc_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PdgDtAplbl", skip_serializing_if = "Option::is_none") )]
	pub pdg_dt_aplbl: Option<PriceStatus2Code>,
}

impl ExerciseDate1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.pdg_dt_aplbl { val.validate()? }
		Ok(())
	}
}


// ExoticOptionStyle1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ExoticOptionStyle1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "BINA") )]
	CodeBINA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DIGI") )]
	CodeDIGI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NOTO") )]
	CodeNOTO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VANI") )]
	CodeVANI,
}

impl ExoticOptionStyle1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ExposureMetrics4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ExposureMetrics4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrncplAmt", skip_serializing_if = "Option::is_none") )]
	pub prncpl_amt: Option<PrincipalAmount3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LnVal", skip_serializing_if = "Option::is_none") )]
	pub ln_val: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktVal", skip_serializing_if = "Option::is_none") )]
	pub mkt_val: Option<AmountAndDirection53>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OutsdngMrgnLnAmt", skip_serializing_if = "Option::is_none") )]
	pub outsdng_mrgn_ln_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ShrtMktValAmt", skip_serializing_if = "Option::is_none") )]
	pub shrt_mkt_val_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MrgnLn", skip_serializing_if = "Option::is_none") )]
	pub mrgn_ln: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshCollAmt", skip_serializing_if = "Option::is_none") )]
	pub csh_coll_amt: Option<AmountAndDirection53>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollMktVal", skip_serializing_if = "Option::is_none") )]
	pub coll_mkt_val: Option<AmountAndDirection53>,
}

impl ExposureMetrics4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.prncpl_amt { val.validate()? }
		if let Some(ref val) = self.ln_val { val.validate()? }
		if let Some(ref val) = self.mkt_val { val.validate()? }
		if let Some(ref val) = self.outsdng_mrgn_ln_amt { val.validate()? }
		if let Some(ref val) = self.shrt_mkt_val_amt { val.validate()? }
		if let Some(ref val) = self.mrgn_ln { val.validate()? }
		if let Some(ref val) = self.csh_coll_amt { val.validate()? }
		if let Some(ref val) = self.coll_mkt_val { val.validate()? }
		Ok(())
	}
}


// ExposureMetrics5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ExposureMetrics5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshCollAmt", skip_serializing_if = "Option::is_none") )]
	pub csh_coll_amt: Option<AmountAndDirection53>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollMktVal", skip_serializing_if = "Option::is_none") )]
	pub coll_mkt_val: Option<AmountAndDirection53>,
}

impl ExposureMetrics5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.csh_coll_amt { val.validate()? }
		if let Some(ref val) = self.coll_mkt_val { val.validate()? }
		Ok(())
	}
}


// ExposureMetrics6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ExposureMetrics6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstdMrgnOrColl", skip_serializing_if = "Option::is_none") )]
	pub pstd_mrgn_or_coll: Option<PostedMarginOrCollateral4>,
}

impl ExposureMetrics6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.pstd_mrgn_or_coll { val.validate()? }
		Ok(())
	}
}


// ExposureType10Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ExposureType10Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "SBSC") )]
	CodeSBSC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MGLD") )]
	CodeMGLD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SLEB") )]
	CodeSLEB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REPO") )]
	CodeREPO,
}

impl ExposureType10Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ExtendedParty13 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ExtendedParty13 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtyRole") )]
	pub pty_role: GenericIdentification36,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrPtyDtls") )]
	pub othr_pty_dtls: ContactAttributes5,
}

impl ExtendedParty13 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pty_role.validate()?;
		self.othr_pty_dtls.validate()?;
		Ok(())
	}
}


// ExtendedParty14 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ExtendedParty14 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "XtndedPtyRole") )]
	pub xtnded_pty_role: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrPtyDtls") )]
	pub othr_pty_dtls: InvestmentAccountOwnershipInformation16,
}

impl ExtendedParty14 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.xtnded_pty_role.chars().count() < 1 {
			return Err(ValidationError::new(1001, "xtnded_pty_role is shorter than the minimum length of 1".to_string()));
		}
		if self.xtnded_pty_role.chars().count() > 350 {
			return Err(ValidationError::new(1002, "xtnded_pty_role exceeds the maximum length of 350".to_string()));
		}
		self.othr_pty_dtls.validate()?;
		Ok(())
	}
}


// ExtendedParty15 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ExtendedParty15 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "XtndedPtyRole") )]
	pub xtnded_pty_role: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrPtyDtls") )]
	pub othr_pty_dtls: InvestmentAccountOwnershipInformation17,
}

impl ExtendedParty15 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.xtnded_pty_role.chars().count() < 1 {
			return Err(ValidationError::new(1001, "xtnded_pty_role is shorter than the minimum length of 1".to_string()));
		}
		if self.xtnded_pty_role.chars().count() > 350 {
			return Err(ValidationError::new(1002, "xtnded_pty_role exceeds the maximum length of 350".to_string()));
		}
		self.othr_pty_dtls.validate()?;
		Ok(())
	}
}


// Extension1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Extension1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PlcAndNm") )]
	pub plc_and_nm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Txt") )]
	pub txt: String,
}

impl Extension1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.plc_and_nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "plc_and_nm is shorter than the minimum length of 1".to_string()));
		}
		if self.plc_and_nm.chars().count() > 350 {
			return Err(ValidationError::new(1002, "plc_and_nm exceeds the maximum length of 350".to_string()));
		}
		if self.txt.chars().count() < 1 {
			return Err(ValidationError::new(1001, "txt is shorter than the minimum length of 1".to_string()));
		}
		if self.txt.chars().count() > 350 {
			return Err(ValidationError::new(1002, "txt exceeds the maximum length of 350".to_string()));
		}
		Ok(())
	}
}


// FATCAForm1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FATCAForm1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<FATCAFormType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl FATCAForm1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// FATCAFormType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum FATCAFormType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CER5") )]
	CodeCER5,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CER7") )]
	CodeCER7,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CER1") )]
	CodeCER1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CER2") )]
	CodeCER2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CER3") )]
	CodeCER3,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CER4") )]
	CodeCER4,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CER6") )]
	CodeCER6,
}

impl FATCAFormType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// FATCASource1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FATCASource1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<FATCASourceStatus1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl FATCASource1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// FATCASourceStatus1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum FATCASourceStatus1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CALC") )]
	CodeCALC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DECL") )]
	CodeDECL,
}

impl FATCASourceStatus1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// FATCAStatus1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum FATCAStatus1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "F101") )]
	CodeF101,
	#[cfg_attr( feature = "derive_serde", serde(rename = "F102") )]
	CodeF102,
	#[cfg_attr( feature = "derive_serde", serde(rename = "F103") )]
	CodeF103,
	#[cfg_attr( feature = "derive_serde", serde(rename = "F104") )]
	CodeF104,
	#[cfg_attr( feature = "derive_serde", serde(rename = "F105") )]
	CodeF105,
	#[cfg_attr( feature = "derive_serde", serde(rename = "F201") )]
	CodeF201,
	#[cfg_attr( feature = "derive_serde", serde(rename = "F202") )]
	CodeF202,
	#[cfg_attr( feature = "derive_serde", serde(rename = "F203") )]
	CodeF203,
	#[cfg_attr( feature = "derive_serde", serde(rename = "F204") )]
	CodeF204,
	#[cfg_attr( feature = "derive_serde", serde(rename = "F205") )]
	CodeF205,
	#[cfg_attr( feature = "derive_serde", serde(rename = "F206") )]
	CodeF206,
}

impl FATCAStatus1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// FATCAStatus2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FATCAStatus2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: FATCAStatus2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Src", skip_serializing_if = "Option::is_none") )]
	pub src: Option<FATCASource1Choice>,
}

impl FATCAStatus2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tp.validate()?;
		if let Some(ref val) = self.src { val.validate()? }
		Ok(())
	}
}


// FATCAStatus2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FATCAStatus2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<FATCAStatus1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl FATCAStatus2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// FailingReason3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum FailingReason3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "AWMO") )]
	CodeAWMO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BYIY") )]
	CodeBYIY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CLAT") )]
	CodeCLAT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ADEA") )]
	CodeADEA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CANR") )]
	CodeCANR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CAIS") )]
	CodeCAIS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OBJT") )]
	CodeOBJT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AWSH") )]
	CodeAWSH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PHSE") )]
	CodePHSE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "STCD") )]
	CodeSTCD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DOCY") )]
	CodeDOCY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MLAT") )]
	CodeMLAT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DOCC") )]
	CodeDOCC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BLOC") )]
	CodeBLOC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CHAS") )]
	CodeCHAS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NEWI") )]
	CodeNEWI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CLAC") )]
	CodeCLAC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MUNO") )]
	CodeMUNO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GLOB") )]
	CodeGLOB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PREA") )]
	CodePREA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PART") )]
	CodePART,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NOFX") )]
	CodeNOFX,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CMON") )]
	CodeCMON,
	#[cfg_attr( feature = "derive_serde", serde(rename = "YCOL") )]
	CodeYCOL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "COLL") )]
	CodeCOLL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DEPO") )]
	CodeDEPO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FLIM") )]
	CodeFLIM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INCA") )]
	CodeINCA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LINK") )]
	CodeLINK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LACK") )]
	CodeLACK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LALO") )]
	CodeLALO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MONY") )]
	CodeMONY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NCON") )]
	CodeNCON,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REFS") )]
	CodeREFS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SDUT") )]
	CodeSDUT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BATC") )]
	CodeBATC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CYCL") )]
	CodeCYCL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SBLO") )]
	CodeSBLO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CPEC") )]
	CodeCPEC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MINO") )]
	CodeMINO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IAAD") )]
	CodeIAAD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PHCK") )]
	CodePHCK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BENO") )]
	CodeBENO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BOTH") )]
	CodeBOTH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CLHT") )]
	CodeCLHT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DENO") )]
	CodeDENO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DISA") )]
	CodeDISA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DKNY") )]
	CodeDKNY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FROZ") )]
	CodeFROZ,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LAAW") )]
	CodeLAAW,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LATE") )]
	CodeLATE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LIQU") )]
	CodeLIQU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRCY") )]
	CodePRCY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REGT") )]
	CodeREGT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SETS") )]
	CodeSETS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CERT") )]
	CodeCERT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRSY") )]
	CodePRSY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INBC") )]
	CodeINBC,
}

impl FailingReason3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// FailingReason7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FailingReason7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd") )]
	pub cd: FailingReason7Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlRsnInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_rsn_inf: Option<String>,
}

impl FailingReason7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.cd.validate()?;
		if let Some(ref val) = self.addtl_rsn_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_rsn_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 210 {
				return Err(ValidationError::new(1002, "addtl_rsn_inf exceeds the maximum length of 210".to_string()));
			}
		}
		Ok(())
	}
}


// FailingReason7Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FailingReason7Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<FailingReason3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl FailingReason7Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// FailingStatus9Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FailingStatus9Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NoSpcfdRsn", skip_serializing_if = "Option::is_none") )]
	pub no_spcfd_rsn: Option<NoReasonCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<Vec<FailingReason7>>,
}

impl FailingStatus9Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.no_spcfd_rsn { val.validate()? }
		if let Some(ref vec) = self.rsn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// FertilizerCommodityAmmonia1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FertilizerCommodityAmmonia1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType5Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType39Code,
}

impl FertilizerCommodityAmmonia1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		Ok(())
	}
}


// FertilizerCommodityAmmonia2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FertilizerCommodityAmmonia2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType5Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType39Code>,
}

impl FertilizerCommodityAmmonia2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// FertilizerCommodityDiammoniumPhosphate1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FertilizerCommodityDiammoniumPhosphate1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType5Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType40Code,
}

impl FertilizerCommodityDiammoniumPhosphate1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		Ok(())
	}
}


// FertilizerCommodityDiammoniumPhosphate2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FertilizerCommodityDiammoniumPhosphate2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType5Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType40Code>,
}

impl FertilizerCommodityDiammoniumPhosphate2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// FertilizerCommodityOther1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FertilizerCommodityOther1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType5Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType49Code,
}

impl FertilizerCommodityOther1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		Ok(())
	}
}


// FertilizerCommodityOther2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FertilizerCommodityOther2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType5Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType49Code>,
}

impl FertilizerCommodityOther2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// FertilizerCommodityPotash1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FertilizerCommodityPotash1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType5Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType41Code,
}

impl FertilizerCommodityPotash1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		Ok(())
	}
}


// FertilizerCommodityPotash2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FertilizerCommodityPotash2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType5Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType41Code>,
}

impl FertilizerCommodityPotash2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// FertilizerCommoditySulphur1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FertilizerCommoditySulphur1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType5Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType42Code,
}

impl FertilizerCommoditySulphur1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		Ok(())
	}
}


// FertilizerCommoditySulphur2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FertilizerCommoditySulphur2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType5Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType42Code>,
}

impl FertilizerCommoditySulphur2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// FertilizerCommodityUrea1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FertilizerCommodityUrea1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType5Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType43Code,
}

impl FertilizerCommodityUrea1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		Ok(())
	}
}


// FertilizerCommodityUrea2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FertilizerCommodityUrea2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType5Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType43Code>,
}

impl FertilizerCommodityUrea2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// FertilizerCommodityUreaAndAmmoniumNitrate1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FertilizerCommodityUreaAndAmmoniumNitrate1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType5Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType44Code,
}

impl FertilizerCommodityUreaAndAmmoniumNitrate1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		Ok(())
	}
}


// FertilizerCommodityUreaAndAmmoniumNitrate2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FertilizerCommodityUreaAndAmmoniumNitrate2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType5Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType44Code>,
}

impl FertilizerCommodityUreaAndAmmoniumNitrate2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// FileData1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FileData1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<DocumentType1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IsseDt", skip_serializing_if = "Option::is_none") )]
	pub isse_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Frmt", skip_serializing_if = "Option::is_none") )]
	pub frmt: Option<DocumentFormat1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FileNm", skip_serializing_if = "Option::is_none") )]
	pub file_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtwkRef", skip_serializing_if = "Option::is_none") )]
	pub ntwk_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FileLctnElctrncAdr", skip_serializing_if = "Option::is_none") )]
	pub file_lctn_elctrnc_adr: Option<String>,
}

impl FileData1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tp { val.validate()? }
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.isse_dt { val.validate()? }
		if let Some(ref val) = self.frmt { val.validate()? }
		if let Some(ref val) = self.file_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "file_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "file_nm exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.ntwk_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ntwk_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "ntwk_ref exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.file_lctn_elctrnc_adr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "file_lctn_elctrnc_adr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 2048 {
				return Err(ValidationError::new(1002, "file_lctn_elctrnc_adr exceeds the maximum length of 2048".to_string()));
			}
		}
		Ok(())
	}
}


// FinalStatus1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum FinalStatus1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "STLD") )]
	CodeSTLD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RJTD") )]
	CodeRJTD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CAND") )]
	CodeCAND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FNLD") )]
	CodeFNLD,
}

impl FinalStatus1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// FinalStatusCode ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum FinalStatusCode {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "STLD") )]
	CodeSTLD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RJTD") )]
	CodeRJTD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CAND") )]
	CodeCAND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FNLD") )]
	CodeFNLD,
}

impl FinalStatusCode {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// FinancialIdentificationSchemeName1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FinancialIdentificationSchemeName1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl FinancialIdentificationSchemeName1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// FinancialInstitutionIdentification11Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FinancialInstitutionIdentification11Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NmAndAdr", skip_serializing_if = "Option::is_none") )]
	pub nm_and_adr: Option<NameAndAddress5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BICFI", skip_serializing_if = "Option::is_none") )]
	pub bicfi: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrSysMmbId", skip_serializing_if = "Option::is_none") )]
	pub clr_sys_mmb_id: Option<ClearingSystemMemberIdentification4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtryId", skip_serializing_if = "Option::is_none") )]
	pub prtry_id: Option<SimpleIdentificationInformation4>,
}

impl FinancialInstitutionIdentification11Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nm_and_adr { val.validate()? }
		if let Some(ref val) = self.bicfi {
			let pattern = Regex::new("[A-Z0-9]{4,4}[A-Z]{2,2}[A-Z0-9]{2,2}([A-Z0-9]{3,3}){0,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "bicfi does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.clr_sys_mmb_id { val.validate()? }
		if let Some(ref val) = self.prtry_id { val.validate()? }
		Ok(())
	}
}


// FinancialInstitutionIdentification18 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FinancialInstitutionIdentification18 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BICFI", skip_serializing_if = "Option::is_none") )]
	pub bicfi: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrSysMmbId", skip_serializing_if = "Option::is_none") )]
	pub clr_sys_mmb_id: Option<ClearingSystemMemberIdentification2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LEI", skip_serializing_if = "Option::is_none") )]
	pub lei: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstlAdr", skip_serializing_if = "Option::is_none") )]
	pub pstl_adr: Option<PostalAddress24>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<GenericFinancialIdentification1>,
}

impl FinancialInstitutionIdentification18 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.bicfi {
			let pattern = Regex::new("[A-Z0-9]{4,4}[A-Z]{2,2}[A-Z0-9]{2,2}([A-Z0-9]{3,3}){0,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "bicfi does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.clr_sys_mmb_id { val.validate()? }
		if let Some(ref val) = self.lei {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "lei does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.pstl_adr { val.validate()? }
		if let Some(ref val) = self.othr { val.validate()? }
		Ok(())
	}
}


// FinancialInstitutionIdentification19 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FinancialInstitutionIdentification19 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BICFI", skip_serializing_if = "Option::is_none") )]
	pub bicfi: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrSysMmbId", skip_serializing_if = "Option::is_none") )]
	pub clr_sys_mmb_id: Option<ClearingSystemMemberIdentification2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LEI", skip_serializing_if = "Option::is_none") )]
	pub lei: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<GenericFinancialIdentification1>,
}

impl FinancialInstitutionIdentification19 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.bicfi {
			let pattern = Regex::new("[A-Z0-9]{4,4}[A-Z]{2,2}[A-Z0-9]{2,2}([A-Z0-9]{3,3}){0,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "bicfi does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.clr_sys_mmb_id { val.validate()? }
		if let Some(ref val) = self.lei {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "lei does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.othr { val.validate()? }
		Ok(())
	}
}


// FinancialInstitutionIdentification23 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FinancialInstitutionIdentification23 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BICFI", skip_serializing_if = "Option::is_none") )]
	pub bicfi: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrSysMmbId", skip_serializing_if = "Option::is_none") )]
	pub clr_sys_mmb_id: Option<ClearingSystemMemberIdentification2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LEI", skip_serializing_if = "Option::is_none") )]
	pub lei: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstlAdr", skip_serializing_if = "Option::is_none") )]
	pub pstl_adr: Option<PostalAddress27>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<GenericFinancialIdentification1>,
}

impl FinancialInstitutionIdentification23 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.bicfi {
			let pattern = Regex::new("[A-Z0-9]{4,4}[A-Z]{2,2}[A-Z0-9]{2,2}([A-Z0-9]{3,3}){0,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "bicfi does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.clr_sys_mmb_id { val.validate()? }
		if let Some(ref val) = self.lei {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "lei does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.pstl_adr { val.validate()? }
		if let Some(ref val) = self.othr { val.validate()? }
		Ok(())
	}
}


// FinancialInstitutionSector1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FinancialInstitutionSector1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sctr") )]
	pub sctr: Vec<FinancialPartyClassification2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrThrshld", skip_serializing_if = "Option::is_none") )]
	pub clr_thrshld: Option<bool>,
}

impl FinancialInstitutionSector1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		for item in &self.sctr { item.validate()? }
		Ok(())
	}
}


// FinancialInstrument104 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FinancialInstrument104 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issr") )]
	pub issr: String,
}

impl FinancialInstrument104 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
		if !pattern.is_match(&self.id) {
			return Err(ValidationError::new(1005, "id does not match the required pattern".to_string()));
		}
		let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
		if !pattern.is_match(&self.issr) {
			return Err(ValidationError::new(1005, "issr does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// FinancialInstrument46Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FinancialInstrument46Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISIN", skip_serializing_if = "Option::is_none") )]
	pub isin: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Indx", skip_serializing_if = "Option::is_none") )]
	pub indx: Option<BenchmarkCurveName2Code>,
}

impl FinancialInstrument46Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.isin {
			let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "isin does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.indx { val.validate()? }
		Ok(())
	}
}


// FinancialInstrument48Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FinancialInstrument48Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISIN", skip_serializing_if = "Option::is_none") )]
	pub isin: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LEI", skip_serializing_if = "Option::is_none") )]
	pub lei: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Indx", skip_serializing_if = "Option::is_none") )]
	pub indx: Option<FinancialInstrument58>,
}

impl FinancialInstrument48Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.isin {
			let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "isin does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.lei {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "lei does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.indx { val.validate()? }
		Ok(())
	}
}


// FinancialInstrument53 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FinancialInstrument53 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISIN", skip_serializing_if = "Option::is_none") )]
	pub isin: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LEI", skip_serializing_if = "Option::is_none") )]
	pub lei: Option<Vec<String>>,
}

impl FinancialInstrument53 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.isin {
			for item in vec {
				let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
				if !pattern.is_match(&item) {
					return Err(ValidationError::new(1005, "isin does not match the required pattern".to_string()));
				}
			}
		}
		if let Some(ref vec) = self.lei {
			for item in vec {
				let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
				if !pattern.is_match(&item) {
					return Err(ValidationError::new(1005, "lei does not match the required pattern".to_string()));
				}
			}
		}
		Ok(())
	}
}


// FinancialInstrument55 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FinancialInstrument55 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: SecurityIdentification25Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ShrtNm", skip_serializing_if = "Option::is_none") )]
	pub shrt_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryId", skip_serializing_if = "Option::is_none") )]
	pub splmtry_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClssTp", skip_serializing_if = "Option::is_none") )]
	pub clss_tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctiesForm", skip_serializing_if = "Option::is_none") )]
	pub scties_form: Option<FormOfSecurity1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DstrbtnPlcy", skip_serializing_if = "Option::is_none") )]
	pub dstrbtn_plcy: Option<DistributionPolicy1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PdctGrp", skip_serializing_if = "Option::is_none") )]
	pub pdct_grp: Option<String>,
}

impl FinancialInstrument55 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.id.validate()?;
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.shrt_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "shrt_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "shrt_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.splmtry_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "splmtry_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "splmtry_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.clss_tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "clss_tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "clss_tp exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.scties_form { val.validate()? }
		if let Some(ref val) = self.dstrbtn_plcy { val.validate()? }
		if let Some(ref val) = self.pdct_grp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pdct_grp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "pdct_grp exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// FinancialInstrument58 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FinancialInstrument58 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISIN", skip_serializing_if = "Option::is_none") )]
	pub isin: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm") )]
	pub nm: FloatingInterestRate8,
}

impl FinancialInstrument58 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.isin {
			let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "isin does not match the required pattern".to_string()));
			}
		}
		self.nm.validate()?;
		Ok(())
	}
}


// FinancialInstrument59 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FinancialInstrument59 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issr") )]
	pub issr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sctr", skip_serializing_if = "Option::is_none") )]
	pub sctr: Option<String>,
}

impl FinancialInstrument59 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
		if !pattern.is_match(&self.id) {
			return Err(ValidationError::new(1005, "id does not match the required pattern".to_string()));
		}
		let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
		if !pattern.is_match(&self.issr) {
			return Err(ValidationError::new(1005, "issr does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// FinancialInstrument71 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FinancialInstrument71 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: SecurityIdentification19,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ShrtNm", skip_serializing_if = "Option::is_none") )]
	pub shrt_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryId", skip_serializing_if = "Option::is_none") )]
	pub splmtry_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClssTp", skip_serializing_if = "Option::is_none") )]
	pub clss_tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctiesForm", skip_serializing_if = "Option::is_none") )]
	pub scties_form: Option<FormOfSecurity1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DstrbtnPlcy", skip_serializing_if = "Option::is_none") )]
	pub dstrbtn_plcy: Option<DistributionPolicy1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PdctGrp", skip_serializing_if = "Option::is_none") )]
	pub pdct_grp: Option<String>,
}

impl FinancialInstrument71 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.id.validate()?;
		if let Some(ref val) = self.shrt_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "shrt_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "shrt_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.splmtry_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "splmtry_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "splmtry_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.clss_tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "clss_tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "clss_tp exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.scties_form { val.validate()? }
		if let Some(ref val) = self.dstrbtn_plcy { val.validate()? }
		if let Some(ref val) = self.pdct_grp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pdct_grp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "pdct_grp exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// FinancialInstrument8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FinancialInstrument8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: Vec<SecurityIdentification3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryId", skip_serializing_if = "Option::is_none") )]
	pub splmtry_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DnmtnCcy", skip_serializing_if = "Option::is_none") )]
	pub dnmtn_ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClssTp", skip_serializing_if = "Option::is_none") )]
	pub clss_tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctiesForm", skip_serializing_if = "Option::is_none") )]
	pub scties_form: Option<FormOfSecurity1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DstrbtnPlcy", skip_serializing_if = "Option::is_none") )]
	pub dstrbtn_plcy: Option<DistributionPolicy1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DualFndInd") )]
	pub dual_fnd_ind: bool,
}

impl FinancialInstrument8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		for item in &self.id { item.validate()? }
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.splmtry_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "splmtry_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "splmtry_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.dnmtn_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "dnmtn_ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.clss_tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "clss_tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "clss_tp exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.scties_form { val.validate()? }
		if let Some(ref val) = self.dstrbtn_plcy { val.validate()? }
		Ok(())
	}
}


// FinancialInstrument87 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FinancialInstrument87 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: SecurityIdentification25Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ShrtNm", skip_serializing_if = "Option::is_none") )]
	pub shrt_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryId", skip_serializing_if = "Option::is_none") )]
	pub splmtry_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClssTp", skip_serializing_if = "Option::is_none") )]
	pub clss_tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctiesForm", skip_serializing_if = "Option::is_none") )]
	pub scties_form: Option<FormOfSecurity1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DstrbtnPlcy", skip_serializing_if = "Option::is_none") )]
	pub dstrbtn_plcy: Option<DistributionPolicy1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PdctGrp", skip_serializing_if = "Option::is_none") )]
	pub pdct_grp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BlckdHldgDtls", skip_serializing_if = "Option::is_none") )]
	pub blckd_hldg_dtls: Option<BlockedHoldingDetails2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pldgg", skip_serializing_if = "Option::is_none") )]
	pub pldgg: Option<Eligible1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Coll", skip_serializing_if = "Option::is_none") )]
	pub coll: Option<Collateral1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ThrdPtyRghts", skip_serializing_if = "Option::is_none") )]
	pub thrd_pty_rghts: Option<ThirdPartyRights2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FndOwnrsh", skip_serializing_if = "Option::is_none") )]
	pub fnd_ownrsh: Option<FundOwnership1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FndIntntn", skip_serializing_if = "Option::is_none") )]
	pub fnd_intntn: Option<FundIntention1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OprlSts", skip_serializing_if = "Option::is_none") )]
	pub oprl_sts: Option<OperationalStatus1Code>,
}

impl FinancialInstrument87 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.id.validate()?;
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.shrt_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "shrt_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "shrt_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.splmtry_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "splmtry_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "splmtry_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.clss_tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "clss_tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "clss_tp exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.scties_form { val.validate()? }
		if let Some(ref val) = self.dstrbtn_plcy { val.validate()? }
		if let Some(ref val) = self.pdct_grp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pdct_grp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "pdct_grp exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.blckd_hldg_dtls { val.validate()? }
		if let Some(ref val) = self.pldgg { val.validate()? }
		if let Some(ref val) = self.coll { val.validate()? }
		if let Some(ref val) = self.thrd_pty_rghts { val.validate()? }
		if let Some(ref val) = self.fnd_ownrsh { val.validate()? }
		if let Some(ref val) = self.fnd_intntn { val.validate()? }
		if let Some(ref val) = self.oprl_sts { val.validate()? }
		Ok(())
	}
}


// FinancialInstrument9 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FinancialInstrument9 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: SecurityIdentification3Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryId", skip_serializing_if = "Option::is_none") )]
	pub splmtry_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdNAVCcy", skip_serializing_if = "Option::is_none") )]
	pub reqd_nav_ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClssTp", skip_serializing_if = "Option::is_none") )]
	pub clss_tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctiesForm", skip_serializing_if = "Option::is_none") )]
	pub scties_form: Option<FormOfSecurity1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DstrbtnPlcy", skip_serializing_if = "Option::is_none") )]
	pub dstrbtn_plcy: Option<DistributionPolicy1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DualFndInd") )]
	pub dual_fnd_ind: bool,
}

impl FinancialInstrument9 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.id.validate()?;
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.splmtry_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "splmtry_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "splmtry_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.reqd_nav_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "reqd_nav_ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.clss_tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "clss_tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "clss_tp exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.scties_form { val.validate()? }
		if let Some(ref val) = self.dstrbtn_plcy { val.validate()? }
		Ok(())
	}
}


// FinancialInstrument96 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FinancialInstrument96 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PhysBrScties", skip_serializing_if = "Option::is_none") )]
	pub phys_br_scties: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DmtrlsdBrScties", skip_serializing_if = "Option::is_none") )]
	pub dmtrlsd_br_scties: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PhysRegdScties", skip_serializing_if = "Option::is_none") )]
	pub phys_regd_scties: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DmtrlsdRegdScties", skip_serializing_if = "Option::is_none") )]
	pub dmtrlsd_regd_scties: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DstrbtnPlcy", skip_serializing_if = "Option::is_none") )]
	pub dstrbtn_plcy: Option<DistributionPolicy1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DvddPlcy", skip_serializing_if = "Option::is_none") )]
	pub dvdd_plcy: Option<DividendPolicy1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DvddFrqcy", skip_serializing_if = "Option::is_none") )]
	pub dvdd_frqcy: Option<EventFrequency5Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RinvstmtFrqcy", skip_serializing_if = "Option::is_none") )]
	pub rinvstmt_frqcy: Option<EventFrequency5Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrntEndLd", skip_serializing_if = "Option::is_none") )]
	pub frnt_end_ld: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BckEndLd", skip_serializing_if = "Option::is_none") )]
	pub bck_end_ld: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SwtchFee", skip_serializing_if = "Option::is_none") )]
	pub swtch_fee: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EUSvgsDrctv", skip_serializing_if = "Option::is_none") )]
	pub eu_svgs_drctv: Option<EUSavingsDirective1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LnchDt", skip_serializing_if = "Option::is_none") )]
	pub lnch_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FndEndDt", skip_serializing_if = "Option::is_none") )]
	pub fnd_end_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TermntnDt", skip_serializing_if = "Option::is_none") )]
	pub termntn_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitlOfferEndDt", skip_serializing_if = "Option::is_none") )]
	pub initl_offer_end_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SspnsnStartDt", skip_serializing_if = "Option::is_none") )]
	pub sspnsn_start_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SspnsnEndDt", skip_serializing_if = "Option::is_none") )]
	pub sspnsn_end_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MtrtyDt", skip_serializing_if = "Option::is_none") )]
	pub mtrty_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MayBeTermntdEarly", skip_serializing_if = "Option::is_none") )]
	pub may_be_termntd_early: Option<TargetMarket1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClsdEndFnd", skip_serializing_if = "Option::is_none") )]
	pub clsd_end_fnd: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Equlstn", skip_serializing_if = "Option::is_none") )]
	pub equlstn: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxEffcntPdctElgbl", skip_serializing_if = "Option::is_none") )]
	pub tax_effcnt_pdct_elgbl: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Authrsd", skip_serializing_if = "Option::is_none") )]
	pub authrsd: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RDRCmplnt", skip_serializing_if = "Option::is_none") )]
	pub rdr_cmplnt: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MgmtFeeSrc", skip_serializing_if = "Option::is_none") )]
	pub mgmt_fee_src: Option<AnnualChargePaymentType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrfrmncFee", skip_serializing_if = "Option::is_none") )]
	pub prfrmnc_fee: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<Vec<AdditionalInformation15>>,
}

impl FinancialInstrument96 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.dstrbtn_plcy { val.validate()? }
		if let Some(ref val) = self.dvdd_plcy { val.validate()? }
		if let Some(ref val) = self.dvdd_frqcy { val.validate()? }
		if let Some(ref val) = self.rinvstmt_frqcy { val.validate()? }
		if let Some(ref val) = self.eu_svgs_drctv { val.validate()? }
		if let Some(ref val) = self.may_be_termntd_early { val.validate()? }
		if let Some(ref val) = self.mgmt_fee_src { val.validate()? }
		if let Some(ref vec) = self.addtl_inf { for item in vec { item.validate()? } }
		Ok(())
	}
}


// FinancialInstrument97 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FinancialInstrument97 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Eqty", skip_serializing_if = "Option::is_none") )]
	pub eqty: Option<Equity3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Warrt", skip_serializing_if = "Option::is_none") )]
	pub warrt: Option<Warrant4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Debt", skip_serializing_if = "Option::is_none") )]
	pub debt: Option<Debt5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Deriv", skip_serializing_if = "Option::is_none") )]
	pub deriv: Option<Derivative4>,
}

impl FinancialInstrument97 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.eqty { val.validate()? }
		if let Some(ref val) = self.warrt { val.validate()? }
		if let Some(ref val) = self.debt { val.validate()? }
		if let Some(ref val) = self.deriv { val.validate()? }
		Ok(())
	}
}


// FinancialInstrument99Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FinancialInstrument99Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StrtgyInstrms", skip_serializing_if = "Option::is_none") )]
	pub strtgy_instrms: Option<Vec<String>>,
}

impl FinancialInstrument99Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.id {
			let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "id does not match the required pattern".to_string()));
			}
		}
		if let Some(ref vec) = self.strtgy_instrms {
			for item in vec {
				let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
				if !pattern.is_match(&item) {
					return Err(ValidationError::new(1005, "strtgy_instrms does not match the required pattern".to_string()));
				}
			}
		}
		Ok(())
	}
}


// FinancialInstrumentAttributes5Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FinancialInstrumentAttributes5Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AltrnId", skip_serializing_if = "Option::is_none") )]
	pub altrn_id: Option<SecurityIdentification19>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<SecurityInstrumentDescription22>,
}

impl FinancialInstrumentAttributes5Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.id {
			let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "id does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.altrn_id { val.validate()? }
		if let Some(ref val) = self.othr { val.validate()? }
		Ok(())
	}
}


// FinancialInstrumentAttributes88 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FinancialInstrumentAttributes88 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctTerm", skip_serializing_if = "Option::is_none") )]
	pub ctrct_term: Option<InterestRateContractTerm1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Stdstn", skip_serializing_if = "Option::is_none") )]
	pub stdstn: Option<Vec<Standardisation1Code>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtFrqcy") )]
	pub pmt_frqcy: Frequency11Code,
}

impl FinancialInstrumentAttributes88 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ctrct_term { val.validate()? }
		if let Some(ref vec) = self.stdstn { for item in vec { item.validate()? } }
		self.pmt_frqcy.validate()?;
		Ok(())
	}
}


// FinancialInstrumentAttributes89 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FinancialInstrumentAttributes89 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctSz") )]
	pub ctrct_sz: ContractSize1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DlvryTp") )]
	pub dlvry_tp: PhysicalTransferType4Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UndrlygId") )]
	pub undrlyg_id: GenericIdentification165,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PricCcy") )]
	pub pric_ccy: String,
}

impl FinancialInstrumentAttributes89 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.ctrct_sz.validate()?;
		self.dlvry_tp.validate()?;
		self.undrlyg_id.validate()?;
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.pric_ccy) {
			return Err(ValidationError::new(1005, "pric_ccy does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// FinancialInstrumentAttributes90 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FinancialInstrumentAttributes90 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ntnl", skip_serializing_if = "Option::is_none") )]
	pub ntnl: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnitVal") )]
	pub unit_val: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IndxId") )]
	pub indx_id: GenericIdentification168,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IndxUnit") )]
	pub indx_unit: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstRateTerms", skip_serializing_if = "Option::is_none") )]
	pub intrst_rate_terms: Option<InterestComputationMethod2Code>,
}

impl FinancialInstrumentAttributes90 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ntnl { val.validate()? }
		self.unit_val.validate()?;
		self.indx_id.validate()?;
		if self.indx_unit.chars().count() < 1 {
			return Err(ValidationError::new(1001, "indx_unit is shorter than the minimum length of 1".to_string()));
		}
		if self.indx_unit.chars().count() > 35 {
			return Err(ValidationError::new(1002, "indx_unit exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.intrst_rate_terms { val.validate()? }
		Ok(())
	}
}


// FinancialInstrumentContractType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum FinancialInstrumentContractType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CFDS") )]
	CodeCFDS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FORW") )]
	CodeFORW,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FRAS") )]
	CodeFRAS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FUTR") )]
	CodeFUTR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OPTN") )]
	CodeOPTN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SPDB") )]
	CodeSPDB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SWAP") )]
	CodeSWAP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SWPT") )]
	CodeSWPT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FONS") )]
	CodeFONS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PSWP") )]
	CodePSWP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FFAS") )]
	CodeFFAS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FWOS") )]
	CodeFWOS,
}

impl FinancialInstrumentContractType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// FinancialInstrumentContractType2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum FinancialInstrumentContractType2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CFDS") )]
	CodeCFDS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FRAS") )]
	CodeFRAS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FUTR") )]
	CodeFUTR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FORW") )]
	CodeFORW,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OPTN") )]
	CodeOPTN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SPDB") )]
	CodeSPDB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SWAP") )]
	CodeSWAP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SWPT") )]
	CodeSWPT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
}

impl FinancialInstrumentContractType2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// FinancialInstrumentForm2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FinancialInstrumentForm2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BookgApprnc", skip_serializing_if = "Option::is_none") )]
	pub bookg_apprnc: Option<Appearance3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LglForm", skip_serializing_if = "Option::is_none") )]
	pub lgl_form: Option<FormOfSecurity8Choice>,
}

impl FinancialInstrumentForm2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.bookg_apprnc { val.validate()? }
		if let Some(ref val) = self.lgl_form { val.validate()? }
		Ok(())
	}
}


// FinancialInstrumentIdentification5Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FinancialInstrumentIdentification5Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sngl", skip_serializing_if = "Option::is_none") )]
	pub sngl: Option<FinancialInstrument48Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Bskt", skip_serializing_if = "Option::is_none") )]
	pub bskt: Option<FinancialInstrument53>,
}

impl FinancialInstrumentIdentification5Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.sngl { val.validate()? }
		if let Some(ref val) = self.bskt { val.validate()? }
		Ok(())
	}
}


// FinancialInstrumentIdentification6Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FinancialInstrumentIdentification6Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISIN", skip_serializing_if = "Option::is_none") )]
	pub isin: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Indx", skip_serializing_if = "Option::is_none") )]
	pub indx: Option<FinancialInstrument58>,
}

impl FinancialInstrumentIdentification6Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.isin {
			let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "isin does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.indx { val.validate()? }
		Ok(())
	}
}


// FinancialInstrumentIdentification7Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FinancialInstrumentIdentification7Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sngl", skip_serializing_if = "Option::is_none") )]
	pub sngl: Option<FinancialInstrumentIdentification6Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Bskt", skip_serializing_if = "Option::is_none") )]
	pub bskt: Option<BasketDescription3>,
}

impl FinancialInstrumentIdentification7Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.sngl { val.validate()? }
		if let Some(ref val) = self.bskt { val.validate()? }
		Ok(())
	}
}


// FinancialInstrumentIdentificationValidity3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FinancialInstrumentIdentificationValidity3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmId", skip_serializing_if = "Option::is_none") )]
	pub fin_instrm_id: Option<SecurityIdentification39>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISINVldFr", skip_serializing_if = "Option::is_none") )]
	pub isin_vld_fr: Option<String>,
}

impl FinancialInstrumentIdentificationValidity3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.fin_instrm_id { val.validate()? }
		Ok(())
	}
}


// FinancialInstrumentName2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FinancialInstrumentName2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISOShrtNm", skip_serializing_if = "Option::is_none") )]
	pub iso_shrt_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISOLngNm", skip_serializing_if = "Option::is_none") )]
	pub iso_lng_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldFr", skip_serializing_if = "Option::is_none") )]
	pub vld_fr: Option<DateAndDateTime2Choice>,
}

impl FinancialInstrumentName2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.iso_shrt_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "iso_shrt_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "iso_shrt_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.iso_lng_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "iso_lng_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "iso_lng_nm exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.vld_fr { val.validate()? }
		Ok(())
	}
}


// FinancialInstrumentProductType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum FinancialInstrumentProductType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CEOD") )]
	CodeCEOD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "COPR") )]
	CodeCOPR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ABCP") )]
	CodeABCP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FRNT") )]
	CodeFRNT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CACM") )]
	CodeCACM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DPST") )]
	CodeDPST,
}

impl FinancialInstrumentProductType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// FinancialInstrumentQuantity1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FinancialInstrumentQuantity1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Unit") )]
	pub unit: f64,
}

impl FinancialInstrumentQuantity1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// FinancialInstrumentQuantity1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FinancialInstrumentQuantity1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Unit", skip_serializing_if = "Option::is_none") )]
	pub unit: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FaceAmt", skip_serializing_if = "Option::is_none") )]
	pub face_amt: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AmtsdVal", skip_serializing_if = "Option::is_none") )]
	pub amtsd_val: Option<f64>,
}

impl FinancialInstrumentQuantity1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.face_amt {
			if *val < 0.000000 {
				return Err(ValidationError::new(1003, "face_amt is less than the minimum value of 0.000000".to_string()));
			}
		}
		if let Some(ref val) = self.amtsd_val {
			if *val < 0.000000 {
				return Err(ValidationError::new(1003, "amtsd_val is less than the minimum value of 0.000000".to_string()));
			}
		}
		Ok(())
	}
}


// FinancialInstrumentQuantity25Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FinancialInstrumentQuantity25Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Unit", skip_serializing_if = "Option::is_none") )]
	pub unit: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NmnlVal", skip_serializing_if = "Option::is_none") )]
	pub nmnl_val: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MntryVal", skip_serializing_if = "Option::is_none") )]
	pub mntry_val: Option<ActiveOrHistoricCurrencyAndAmount>,
}

impl FinancialInstrumentQuantity25Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nmnl_val { val.validate()? }
		if let Some(ref val) = self.mntry_val { val.validate()? }
		Ok(())
	}
}


// FinancialInstrumentQuantity32Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FinancialInstrumentQuantity32Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Unit", skip_serializing_if = "Option::is_none") )]
	pub unit: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NmnlVal", skip_serializing_if = "Option::is_none") )]
	pub nmnl_val: Option<ActiveOrHistoricCurrencyAnd19DecimalAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MntryVal", skip_serializing_if = "Option::is_none") )]
	pub mntry_val: Option<ActiveOrHistoricCurrencyAnd19DecimalAmount>,
}

impl FinancialInstrumentQuantity32Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nmnl_val { val.validate()? }
		if let Some(ref val) = self.mntry_val { val.validate()? }
		Ok(())
	}
}


// FinancialPartyClassification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FinancialPartyClassification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Clssfctn") )]
	pub clssfctn: Vec<FinancialPartySectorType2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstmtFndClssfctn", skip_serializing_if = "Option::is_none") )]
	pub invstmt_fnd_clssfctn: Option<FundType2Code>,
}

impl FinancialPartyClassification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		for item in &self.clssfctn { item.validate()? }
		if let Some(ref val) = self.invstmt_fnd_clssfctn { val.validate()? }
		Ok(())
	}
}


// FinancialPartyClassification2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FinancialPartyClassification2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Clssfctn") )]
	pub clssfctn: Vec<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstmtFndClssfctn", skip_serializing_if = "Option::is_none") )]
	pub invstmt_fnd_clssfctn: Option<FundType2Code>,
}

impl FinancialPartyClassification2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		for item in &self.clssfctn {
			let pattern = Regex::new("[A-U]{1,1}").unwrap();
			if !pattern.is_match(&item) {
				return Err(ValidationError::new(1005, "clssfctn does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.invstmt_fnd_clssfctn { val.validate()? }
		Ok(())
	}
}


// FinancialPartyClassification2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FinancialPartyClassification2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<FinancialPartySectorType3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification175>,
}

impl FinancialPartyClassification2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// FinancialPartySectorType2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum FinancialPartySectorType2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "AIFD") )]
	CodeAIFD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CSDS") )]
	CodeCSDS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CCPS") )]
	CodeCCPS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CDTI") )]
	CodeCDTI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INUN") )]
	CodeINUN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ORPI") )]
	CodeORPI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INVF") )]
	CodeINVF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REIN") )]
	CodeREIN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UCIT") )]
	CodeUCIT,
}

impl FinancialPartySectorType2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// FinancialPartySectorType3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum FinancialPartySectorType3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "AIFD") )]
	CodeAIFD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CSDS") )]
	CodeCSDS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CCPS") )]
	CodeCCPS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CDTI") )]
	CodeCDTI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INUN") )]
	CodeINUN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ORPI") )]
	CodeORPI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INVF") )]
	CodeINVF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REIN") )]
	CodeREIN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UCIT") )]
	CodeUCIT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ASSU") )]
	CodeASSU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
}

impl FinancialPartySectorType3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// FiscalYear1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FiscalYear1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "StartDt", skip_serializing_if = "Option::is_none") )]
	pub start_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndDt", skip_serializing_if = "Option::is_none") )]
	pub end_dt: Option<String>,
}

impl FiscalYear1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// FixedAmountOrUnlimited1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FixedAmountOrUnlimited1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NotLtd", skip_serializing_if = "Option::is_none") )]
	pub not_ltd: Option<String>,
}

impl FixedAmountOrUnlimited1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.amt { val.validate()? }
		if let Some(ref val) = self.not_ltd {
			if val.chars().count() < 9 {
				return Err(ValidationError::new(1001, "not_ltd is shorter than the minimum length of 9".to_string()));
			}
			if val.chars().count() > 9 {
				return Err(ValidationError::new(1002, "not_ltd exceeds the maximum length of 9".to_string()));
			}
			let pattern = Regex::new("UNLIMITED").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "not_ltd does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// FixedOpenTermContract2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FixedOpenTermContract2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MtrtyDt", skip_serializing_if = "Option::is_none") )]
	pub mtrty_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TermntnOptn", skip_serializing_if = "Option::is_none") )]
	pub termntn_optn: Option<RepoTerminationOption2Code>,
}

impl FixedOpenTermContract2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.termntn_optn { val.validate()? }
		Ok(())
	}
}


// FixedRate10 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FixedRate10 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rate", skip_serializing_if = "Option::is_none") )]
	pub rate: Option<SecuritiesTransactionPrice14Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DayCnt", skip_serializing_if = "Option::is_none") )]
	pub day_cnt: Option<InterestComputationMethodFormat7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtFrqcy", skip_serializing_if = "Option::is_none") )]
	pub pmt_frqcy: Option<InterestRateFrequency3Choice>,
}

impl FixedRate10 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rate { val.validate()? }
		if let Some(ref val) = self.day_cnt { val.validate()? }
		if let Some(ref val) = self.pmt_frqcy { val.validate()? }
		Ok(())
	}
}


// FixedRate11 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FixedRate11 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rate", skip_serializing_if = "Option::is_none") )]
	pub rate: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DayCntBsis", skip_serializing_if = "Option::is_none") )]
	pub day_cnt_bsis: Option<InterestComputationMethodFormat6Choice>,
}

impl FixedRate11 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.day_cnt_bsis { val.validate()? }
		Ok(())
	}
}


// FloatingInterestRate22 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FloatingInterestRate22 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RefRate", skip_serializing_if = "Option::is_none") )]
	pub ref_rate: Option<BenchmarkCurveName10Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Term", skip_serializing_if = "Option::is_none") )]
	pub term: Option<InterestRateContractTerm2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtFrqcy", skip_serializing_if = "Option::is_none") )]
	pub pmt_frqcy: Option<InterestRateContractTerm2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RstFrqcy", skip_serializing_if = "Option::is_none") )]
	pub rst_frqcy: Option<InterestRateContractTerm2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sprd", skip_serializing_if = "Option::is_none") )]
	pub sprd: Option<SecuritiesTransactionPrice18Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RateAdjstmnt", skip_serializing_if = "Option::is_none") )]
	pub rate_adjstmnt: Option<Vec<RateAdjustment1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DayCntBsis", skip_serializing_if = "Option::is_none") )]
	pub day_cnt_bsis: Option<InterestComputationMethodFormat6Choice>,
}

impl FloatingInterestRate22 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ref_rate { val.validate()? }
		if let Some(ref val) = self.term { val.validate()? }
		if let Some(ref val) = self.pmt_frqcy { val.validate()? }
		if let Some(ref val) = self.rst_frqcy { val.validate()? }
		if let Some(ref val) = self.sprd { val.validate()? }
		if let Some(ref vec) = self.rate_adjstmnt { for item in vec { item.validate()? } }
		if let Some(ref val) = self.day_cnt_bsis { val.validate()? }
		Ok(())
	}
}


// FloatingInterestRate4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FloatingInterestRate4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RefRate") )]
	pub ref_rate: BenchmarkCurveName4Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Term") )]
	pub term: InterestRateContractTerm1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BsisPtSprd") )]
	pub bsis_pt_sprd: f64,
}

impl FloatingInterestRate4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.ref_rate.validate()?;
		self.term.validate()?;
		Ok(())
	}
}


// FloatingInterestRate6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FloatingInterestRate6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RefRate") )]
	pub ref_rate: BenchmarkCurveName6Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Term") )]
	pub term: InterestRateContractTerm2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BsisPtSprd") )]
	pub bsis_pt_sprd: f64,
}

impl FloatingInterestRate6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.ref_rate.validate()?;
		self.term.validate()?;
		Ok(())
	}
}


// FloatingInterestRate8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FloatingInterestRate8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RefRate") )]
	pub ref_rate: BenchmarkCurveName5Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Term", skip_serializing_if = "Option::is_none") )]
	pub term: Option<InterestRateContractTerm2>,
}

impl FloatingInterestRate8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.ref_rate.validate()?;
		if let Some(ref val) = self.term { val.validate()? }
		Ok(())
	}
}


// FloatingRate13 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FloatingRate13 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rate", skip_serializing_if = "Option::is_none") )]
	pub rate: Option<FloatingRateIdentification8Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RefPrd", skip_serializing_if = "Option::is_none") )]
	pub ref_prd: Option<InterestRateContractTerm4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sprd", skip_serializing_if = "Option::is_none") )]
	pub sprd: Option<SecuritiesTransactionPrice20Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DayCnt", skip_serializing_if = "Option::is_none") )]
	pub day_cnt: Option<InterestComputationMethodFormat7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtFrqcy", skip_serializing_if = "Option::is_none") )]
	pub pmt_frqcy: Option<InterestRateFrequency3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RstFrqcy", skip_serializing_if = "Option::is_none") )]
	pub rst_frqcy: Option<InterestRateFrequency3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NxtFltgRst", skip_serializing_if = "Option::is_none") )]
	pub nxt_fltg_rst: Option<ResetDateAndValue1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LastFltgRst", skip_serializing_if = "Option::is_none") )]
	pub last_fltg_rst: Option<ResetDateAndValue1>,
}

impl FloatingRate13 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.id {
			let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "id does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.rate { val.validate()? }
		if let Some(ref val) = self.ref_prd { val.validate()? }
		if let Some(ref val) = self.sprd { val.validate()? }
		if let Some(ref val) = self.day_cnt { val.validate()? }
		if let Some(ref val) = self.pmt_frqcy { val.validate()? }
		if let Some(ref val) = self.rst_frqcy { val.validate()? }
		if let Some(ref val) = self.nxt_fltg_rst { val.validate()? }
		if let Some(ref val) = self.last_fltg_rst { val.validate()? }
		Ok(())
	}
}


// FloatingRateIdentification8Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FloatingRateIdentification8Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl FloatingRateIdentification8Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 350".to_string()));
			}
		}
		Ok(())
	}
}


// FloatingRateNote2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FloatingRateNote2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RefRateIndx") )]
	pub ref_rate_indx: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BsisPtSprd") )]
	pub bsis_pt_sprd: f64,
}

impl FloatingRateNote2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
		if !pattern.is_match(&self.ref_rate_indx) {
			return Err(ValidationError::new(1005, "ref_rate_indx does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// FloorLimitType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum FloorLimitType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CRED") )]
	CodeCRED,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DEBT") )]
	CodeDEBT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BOTH") )]
	CodeBOTH,
}

impl FloorLimitType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// FlowDirectionType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum FlowDirectionType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "INCG") )]
	CodeINCG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OUTG") )]
	CodeOUTG,
}

impl FlowDirectionType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Flows1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Flows1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtBkFlows") )]
	pub pmt_bk_flows: AmountAndDirection102,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstmtFlows") )]
	pub invstmt_flows: AmountAndDirection102,
}

impl Flows1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pmt_bk_flows.validate()?;
		self.invstmt_flows.validate()?;
		Ok(())
	}
}


// ForeignExchange1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ForeignExchange1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrgnCcy") )]
	pub frgn_ccy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XchgSpotRate") )]
	pub xchg_spot_rate: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XchgFwdPt") )]
	pub xchg_fwd_pt: f64,
}

impl ForeignExchange1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.frgn_ccy) {
			return Err(ValidationError::new(1005, "frgn_ccy does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// ForeignExchangeDerivative2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ForeignExchangeDerivative2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctSubTp") )]
	pub ctrct_sub_tp: AssetClassSubProductType19Code,
}

impl ForeignExchangeDerivative2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.ctrct_sub_tp.validate()?;
		Ok(())
	}
}


// ForeignExchangeSwap3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ForeignExchangeSwap3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DataSetActn", skip_serializing_if = "Option::is_none") )]
	pub data_set_actn: Option<ReportPeriodActivity3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tx", skip_serializing_if = "Option::is_none") )]
	pub tx: Option<Vec<ForeignExchangeSwapTransaction3>>,
}

impl ForeignExchangeSwap3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.data_set_actn { val.validate()? }
		if let Some(ref vec) = self.tx { for item in vec { item.validate()? } }
		Ok(())
	}
}


// ForeignExchangeSwapTransaction3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ForeignExchangeSwapTransaction3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptdTxSts") )]
	pub rptd_tx_sts: TransactionOperationType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NvtnSts", skip_serializing_if = "Option::is_none") )]
	pub nvtn_sts: Option<NovationStatus1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BrnchId", skip_serializing_if = "Option::is_none") )]
	pub brnch_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnqTxIdr", skip_serializing_if = "Option::is_none") )]
	pub unq_tx_idr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtryTxId") )]
	pub prtry_tx_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdPrtryTxId", skip_serializing_if = "Option::is_none") )]
	pub rltd_prtry_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtyPrtryTxId", skip_serializing_if = "Option::is_none") )]
	pub ctr_pty_prtry_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtyId") )]
	pub ctr_pty_id: CounterpartyIdentification3Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradDt") )]
	pub trad_dt: DateAndDateTimeChoice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SpotValDt") )]
	pub spot_val_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MtrtyDt") )]
	pub mtrty_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxTp") )]
	pub tx_tp: SecuritiesTransactionType15Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxNmnlAmt") )]
	pub tx_nmnl_amt: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FX") )]
	pub fx: ForeignExchange1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl ForeignExchangeSwapTransaction3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.rptd_tx_sts.validate()?;
		if let Some(ref val) = self.nvtn_sts { val.validate()? }
		if let Some(ref val) = self.brnch_id {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "brnch_id does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.unq_tx_idr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "unq_tx_idr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 105 {
				return Err(ValidationError::new(1002, "unq_tx_idr exceeds the maximum length of 105".to_string()));
			}
		}
		if self.prtry_tx_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "prtry_tx_id is shorter than the minimum length of 1".to_string()));
		}
		if self.prtry_tx_id.chars().count() > 105 {
			return Err(ValidationError::new(1002, "prtry_tx_id exceeds the maximum length of 105".to_string()));
		}
		if let Some(ref val) = self.rltd_prtry_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rltd_prtry_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 105 {
				return Err(ValidationError::new(1002, "rltd_prtry_tx_id exceeds the maximum length of 105".to_string()));
			}
		}
		if let Some(ref val) = self.ctr_pty_prtry_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ctr_pty_prtry_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 105 {
				return Err(ValidationError::new(1002, "ctr_pty_prtry_tx_id exceeds the maximum length of 105".to_string()));
			}
		}
		self.ctr_pty_id.validate()?;
		self.trad_dt.validate()?;
		self.tx_tp.validate()?;
		self.tx_nmnl_amt.validate()?;
		self.fx.validate()?;
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// ForeignExchangeTerms19 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ForeignExchangeTerms19 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnitCcy") )]
	pub unit_ccy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QtdCcy") )]
	pub qtd_ccy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XchgRate") )]
	pub xchg_rate: f64,
}

impl ForeignExchangeTerms19 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.unit_ccy) {
			return Err(ValidationError::new(1005, "unit_ccy does not match the required pattern".to_string()));
		}
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.qtd_ccy) {
			return Err(ValidationError::new(1005, "qtd_ccy does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// FormOfSecurity1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum FormOfSecurity1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "BEAR") )]
	CodeBEAR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REGD") )]
	CodeREGD,
}

impl FormOfSecurity1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// FormOfSecurity8Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FormOfSecurity8Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<FormOfSecurity1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl FormOfSecurity8Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// Forms1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Forms1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ApplForm") )]
	pub appl_form: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SgntrTp") )]
	pub sgntr_tp: SignatureType1Code,
}

impl Forms1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.sgntr_tp.validate()?;
		Ok(())
	}
}


// FreightCommodityContainerShip1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FreightCommodityContainerShip1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType4Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType46Code,
}

impl FreightCommodityContainerShip1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		Ok(())
	}
}


// FreightCommodityContainerShip2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FreightCommodityContainerShip2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType4Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType46Code>,
}

impl FreightCommodityContainerShip2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// FreightCommodityDry1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FreightCommodityDry1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType4Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType31Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlSubPdct", skip_serializing_if = "Option::is_none") )]
	pub addtl_sub_pdct: Option<AssetClassDetailedSubProductType14Code>,
}

impl FreightCommodityDry1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		if let Some(ref val) = self.addtl_sub_pdct { val.validate()? }
		Ok(())
	}
}


// FreightCommodityDry2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FreightCommodityDry2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType4Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType31Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlSubPdct") )]
	pub addtl_sub_pdct: AssetClassDetailedSubProductType33Code,
}

impl FreightCommodityDry2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		self.addtl_sub_pdct.validate()?;
		Ok(())
	}
}


// FreightCommodityDry3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FreightCommodityDry3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType4Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType31Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlSubPdct", skip_serializing_if = "Option::is_none") )]
	pub addtl_sub_pdct: Option<AssetClassDetailedSubProductType33Code>,
}

impl FreightCommodityDry3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		if let Some(ref val) = self.addtl_sub_pdct { val.validate()? }
		Ok(())
	}
}


// FreightCommodityOther1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FreightCommodityOther1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType4Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType49Code,
}

impl FreightCommodityOther1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		Ok(())
	}
}


// FreightCommodityOther2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FreightCommodityOther2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType4Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType49Code>,
}

impl FreightCommodityOther2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// FreightCommodityWet1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FreightCommodityWet1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType4Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType32Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlSubPdct", skip_serializing_if = "Option::is_none") )]
	pub addtl_sub_pdct: Option<AssetClassDetailedSubProductType12Code>,
}

impl FreightCommodityWet1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		if let Some(ref val) = self.addtl_sub_pdct { val.validate()? }
		Ok(())
	}
}


// FreightCommodityWet2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FreightCommodityWet2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType4Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType32Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlSubPdct") )]
	pub addtl_sub_pdct: AssetClassDetailedSubProductType34Code,
}

impl FreightCommodityWet2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		self.addtl_sub_pdct.validate()?;
		Ok(())
	}
}


// FreightCommodityWet3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FreightCommodityWet3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType4Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType32Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlSubPdct", skip_serializing_if = "Option::is_none") )]
	pub addtl_sub_pdct: Option<AssetClassDetailedSubProductType34Code>,
}

impl FreightCommodityWet3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		if let Some(ref val) = self.addtl_sub_pdct { val.validate()? }
		Ok(())
	}
}


// Frequency1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Frequency1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Seq", skip_serializing_if = "Option::is_none") )]
	pub seq: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StartDt") )]
	pub start_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndPtChc") )]
	pub end_pt_chc: EndPoint1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdFrqcyPttrn", skip_serializing_if = "Option::is_none") )]
	pub reqd_frqcy_pttrn: Option<Frequency37Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NonWorkgDayAdjstmnt", skip_serializing_if = "Option::is_none") )]
	pub non_workg_day_adjstmnt: Option<BusinessDayConvention1Code>,
}

impl Frequency1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.seq {
			let pattern = Regex::new("[0-9]{1,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "seq does not match the required pattern".to_string()));
			}
		}
		self.end_pt_chc.validate()?;
		if let Some(ref val) = self.reqd_frqcy_pttrn { val.validate()? }
		if let Some(ref val) = self.non_workg_day_adjstmnt { val.validate()? }
		Ok(())
	}
}


// Frequency10Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum Frequency10Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "NEVR") )]
	CodeNEVR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "YEAR") )]
	CodeYEAR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RATE") )]
	CodeRATE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MIAN") )]
	CodeMIAN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QURT") )]
	CodeQURT,
}

impl Frequency10Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Frequency11Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum Frequency11Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "YEAR") )]
	CodeYEAR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DAIL") )]
	CodeDAIL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MNTH") )]
	CodeMNTH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EXPI") )]
	CodeEXPI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OVNG") )]
	CodeOVNG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QURT") )]
	CodeQURT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MIAN") )]
	CodeMIAN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UPFR") )]
	CodeUPFR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WEEK") )]
	CodeWEEK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CRED") )]
	CodeCRED,
}

impl Frequency11Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Frequency13Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum Frequency13Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "DAIL") )]
	CodeDAIL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WEEK") )]
	CodeWEEK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MNTH") )]
	CodeMNTH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "YEAR") )]
	CodeYEAR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ADHO") )]
	CodeADHO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EXPI") )]
	CodeEXPI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MIAN") )]
	CodeMIAN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QURT") )]
	CodeQURT,
}

impl Frequency13Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Frequency14Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum Frequency14Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "DAIL") )]
	CodeDAIL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WEEK") )]
	CodeWEEK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MNTH") )]
	CodeMNTH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ADHO") )]
	CodeADHO,
}

impl Frequency14Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Frequency19Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum Frequency19Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "DAIL") )]
	CodeDAIL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WEEK") )]
	CodeWEEK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MNTH") )]
	CodeMNTH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "YEAR") )]
	CodeYEAR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ADHO") )]
	CodeADHO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EXPI") )]
	CodeEXPI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MIAN") )]
	CodeMIAN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QURT") )]
	CodeQURT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HOUL") )]
	CodeHOUL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ODMD") )]
	CodeODMD,
}

impl Frequency19Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Frequency20Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Frequency20Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<EventFrequency8Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl Frequency20Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// Frequency22Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Frequency22Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<EventFrequency7Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl Frequency22Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// Frequency2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum Frequency2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "YEAR") )]
	CodeYEAR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MNTH") )]
	CodeMNTH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QURT") )]
	CodeQURT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MIAN") )]
	CodeMIAN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WEEK") )]
	CodeWEEK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DAIL") )]
	CodeDAIL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ADHO") )]
	CodeADHO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INDA") )]
	CodeINDA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OVNG") )]
	CodeOVNG,
}

impl Frequency2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Frequency35Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Frequency35Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<Frequency5Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl Frequency35Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// Frequency36Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Frequency36Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<Frequency6Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prd", skip_serializing_if = "Option::is_none") )]
	pub prd: Option<FrequencyPeriod1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtInTm", skip_serializing_if = "Option::is_none") )]
	pub pt_in_tm: Option<FrequencyAndMoment1>,
}

impl Frequency36Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.prd { val.validate()? }
		if let Some(ref val) = self.pt_in_tm { val.validate()? }
		Ok(())
	}
}


// Frequency37Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Frequency37Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<Frequency10Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl Frequency37Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// Frequency5Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum Frequency5Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "YEAR") )]
	CodeYEAR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MNTH") )]
	CodeMNTH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QURT") )]
	CodeQURT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MIAN") )]
	CodeMIAN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WEEK") )]
	CodeWEEK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DAIL") )]
	CodeDAIL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ADHO") )]
	CodeADHO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INDA") )]
	CodeINDA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OVNG") )]
	CodeOVNG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TEND") )]
	CodeTEND,
}

impl Frequency5Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Frequency6Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum Frequency6Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "YEAR") )]
	CodeYEAR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MNTH") )]
	CodeMNTH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QURT") )]
	CodeQURT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MIAN") )]
	CodeMIAN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WEEK") )]
	CodeWEEK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DAIL") )]
	CodeDAIL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ADHO") )]
	CodeADHO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INDA") )]
	CodeINDA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FRTN") )]
	CodeFRTN,
}

impl Frequency6Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Frequency7Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum Frequency7Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "YEAR") )]
	CodeYEAR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DAIL") )]
	CodeDAIL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MNTH") )]
	CodeMNTH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QURT") )]
	CodeQURT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MIAN") )]
	CodeMIAN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TEND") )]
	CodeTEND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MOVE") )]
	CodeMOVE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WEEK") )]
	CodeWEEK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INDA") )]
	CodeINDA,
}

impl Frequency7Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// FrequencyAndMoment1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FrequencyAndMoment1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: Frequency6Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtInTm") )]
	pub pt_in_tm: String,
}

impl FrequencyAndMoment1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tp.validate()?;
		let pattern = Regex::new("[0-9]{2}").unwrap();
		if !pattern.is_match(&self.pt_in_tm) {
			return Err(ValidationError::new(1005, "pt_in_tm does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// FrequencyPeriod1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FrequencyPeriod1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: Frequency6Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CntPerPrd") )]
	pub cnt_per_prd: f64,
}

impl FrequencyPeriod1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tp.validate()?;
		Ok(())
	}
}


// FromToAmountRange1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FromToAmountRange1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrAmt") )]
	pub fr_amt: AmountRangeBoundary1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ToAmt") )]
	pub to_amt: AmountRangeBoundary1,
}

impl FromToAmountRange1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.fr_amt.validate()?;
		self.to_amt.validate()?;
		Ok(())
	}
}


// FromToPercentageRange1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FromToPercentageRange1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Fr") )]
	pub fr: PercentageRangeBoundary1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "To") )]
	pub to: PercentageRangeBoundary1,
}

impl FromToPercentageRange1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.fr.validate()?;
		self.to.validate()?;
		Ok(())
	}
}


// FromToQuantityRange2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FromToQuantityRange2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrQty") )]
	pub fr_qty: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ToQty") )]
	pub to_qty: f64,
}

impl FromToQuantityRange2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// FullLegalNameModification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FullLegalNameModification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModCd", skip_serializing_if = "Option::is_none") )]
	pub mod_cd: Option<Modification1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FullLglNm") )]
	pub full_lgl_nm: String,
}

impl FullLegalNameModification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mod_cd { val.validate()? }
		if self.full_lgl_nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "full_lgl_nm is shorter than the minimum length of 1".to_string()));
		}
		if self.full_lgl_nm.chars().count() > 350 {
			return Err(ValidationError::new(1002, "full_lgl_nm exceeds the maximum length of 350".to_string()));
		}
		Ok(())
	}
}


// Fund1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Fund1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LglNttyIdr", skip_serializing_if = "Option::is_none") )]
	pub lgl_ntty_idr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<OtherIdentification4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ccy", skip_serializing_if = "Option::is_none") )]
	pub ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradDtTm", skip_serializing_if = "Option::is_none") )]
	pub trad_dt_tm: Option<DateAndDateTimeChoice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsTradDtTm", skip_serializing_if = "Option::is_none") )]
	pub prvs_trad_dt_tm: Option<DateAndDateTimeChoice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EstmtdTtlNAV", skip_serializing_if = "Option::is_none") )]
	pub estmtd_ttl_nav: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsTtlNAV", skip_serializing_if = "Option::is_none") )]
	pub prvs_ttl_nav: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EstmtdTtlUnitsNb", skip_serializing_if = "Option::is_none") )]
	pub estmtd_ttl_units_nb: Option<FinancialInstrumentQuantity1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsTtlUnitsNb", skip_serializing_if = "Option::is_none") )]
	pub prvs_ttl_units_nb: Option<FinancialInstrumentQuantity1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EstmtdPctgOfFndTtlNAV", skip_serializing_if = "Option::is_none") )]
	pub estmtd_pctg_of_fnd_ttl_nav: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EstmtdCshInFcstDtls", skip_serializing_if = "Option::is_none") )]
	pub estmtd_csh_in_fcst_dtls: Option<Vec<CashInOutForecast7>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EstmtdCshOutFcstDtls", skip_serializing_if = "Option::is_none") )]
	pub estmtd_csh_out_fcst_dtls: Option<Vec<CashInOutForecast7>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EstmtdNetCshFcstDtls", skip_serializing_if = "Option::is_none") )]
	pub estmtd_net_csh_fcst_dtls: Option<Vec<NetCashForecast5>>,
}

impl Fund1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.lgl_ntty_idr {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "lgl_ntty_idr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.id { val.validate()? }
		if let Some(ref val) = self.ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.trad_dt_tm { val.validate()? }
		if let Some(ref val) = self.prvs_trad_dt_tm { val.validate()? }
		if let Some(ref val) = self.estmtd_ttl_nav { val.validate()? }
		if let Some(ref val) = self.prvs_ttl_nav { val.validate()? }
		if let Some(ref val) = self.estmtd_ttl_units_nb { val.validate()? }
		if let Some(ref val) = self.prvs_ttl_units_nb { val.validate()? }
		if let Some(ref vec) = self.estmtd_csh_in_fcst_dtls { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.estmtd_csh_out_fcst_dtls { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.estmtd_net_csh_fcst_dtls { for item in vec { item.validate()? } }
		Ok(())
	}
}


// Fund2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Fund2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LglNttyIdr", skip_serializing_if = "Option::is_none") )]
	pub lgl_ntty_idr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<OtherIdentification4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ccy", skip_serializing_if = "Option::is_none") )]
	pub ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradDtTm", skip_serializing_if = "Option::is_none") )]
	pub trad_dt_tm: Option<DateAndDateTimeChoice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsTradDtTm", skip_serializing_if = "Option::is_none") )]
	pub prvs_trad_dt_tm: Option<DateAndDateTimeChoice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNAV", skip_serializing_if = "Option::is_none") )]
	pub ttl_nav: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsTtlNAV", skip_serializing_if = "Option::is_none") )]
	pub prvs_ttl_nav: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlUnitsNb", skip_serializing_if = "Option::is_none") )]
	pub ttl_units_nb: Option<FinancialInstrumentQuantity1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsTtlUnitsNb", skip_serializing_if = "Option::is_none") )]
	pub prvs_ttl_units_nb: Option<FinancialInstrumentQuantity1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PctgOfFndTtlNAV", skip_serializing_if = "Option::is_none") )]
	pub pctg_of_fnd_ttl_nav: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshInFcstDtls", skip_serializing_if = "Option::is_none") )]
	pub csh_in_fcst_dtls: Option<Vec<CashInOutForecast7>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshOutFcstDtls", skip_serializing_if = "Option::is_none") )]
	pub csh_out_fcst_dtls: Option<Vec<CashInOutForecast7>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NetCshFcstDtls", skip_serializing_if = "Option::is_none") )]
	pub net_csh_fcst_dtls: Option<Vec<NetCashForecast5>>,
}

impl Fund2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.lgl_ntty_idr {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "lgl_ntty_idr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.id { val.validate()? }
		if let Some(ref val) = self.ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.trad_dt_tm { val.validate()? }
		if let Some(ref val) = self.prvs_trad_dt_tm { val.validate()? }
		if let Some(ref val) = self.ttl_nav { val.validate()? }
		if let Some(ref val) = self.prvs_ttl_nav { val.validate()? }
		if let Some(ref val) = self.ttl_units_nb { val.validate()? }
		if let Some(ref val) = self.prvs_ttl_units_nb { val.validate()? }
		if let Some(ref vec) = self.csh_in_fcst_dtls { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.csh_out_fcst_dtls { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.net_csh_fcst_dtls { for item in vec { item.validate()? } }
		Ok(())
	}
}


// Fund3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Fund3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LglNttyIdr", skip_serializing_if = "Option::is_none") )]
	pub lgl_ntty_idr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<OtherIdentification4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ccy", skip_serializing_if = "Option::is_none") )]
	pub ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EstmtdTtlNAV", skip_serializing_if = "Option::is_none") )]
	pub estmtd_ttl_nav: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsTtlNAV", skip_serializing_if = "Option::is_none") )]
	pub prvs_ttl_nav: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EstmtdTtlUnitsNb", skip_serializing_if = "Option::is_none") )]
	pub estmtd_ttl_units_nb: Option<FinancialInstrumentQuantity1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsTtlUnitsNb", skip_serializing_if = "Option::is_none") )]
	pub prvs_ttl_units_nb: Option<FinancialInstrumentQuantity1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EstmtdPctgOfFndTtlNAV", skip_serializing_if = "Option::is_none") )]
	pub estmtd_pctg_of_fnd_ttl_nav: Option<f64>,
}

impl Fund3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.lgl_ntty_idr {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "lgl_ntty_idr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.id { val.validate()? }
		if let Some(ref val) = self.ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.estmtd_ttl_nav { val.validate()? }
		if let Some(ref val) = self.prvs_ttl_nav { val.validate()? }
		if let Some(ref val) = self.estmtd_ttl_units_nb { val.validate()? }
		if let Some(ref val) = self.prvs_ttl_units_nb { val.validate()? }
		Ok(())
	}
}


// Fund4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Fund4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LglNttyIdr", skip_serializing_if = "Option::is_none") )]
	pub lgl_ntty_idr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<OtherIdentification4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ccy", skip_serializing_if = "Option::is_none") )]
	pub ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNAV", skip_serializing_if = "Option::is_none") )]
	pub ttl_nav: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsTtlNAV", skip_serializing_if = "Option::is_none") )]
	pub prvs_ttl_nav: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlUnitsNb", skip_serializing_if = "Option::is_none") )]
	pub ttl_units_nb: Option<FinancialInstrumentQuantity1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsTtlUnitsNb", skip_serializing_if = "Option::is_none") )]
	pub prvs_ttl_units_nb: Option<FinancialInstrumentQuantity1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PctgOfFndTtlNAV", skip_serializing_if = "Option::is_none") )]
	pub pctg_of_fnd_ttl_nav: Option<f64>,
}

impl Fund4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.lgl_ntty_idr {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "lgl_ntty_idr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.id { val.validate()? }
		if let Some(ref val) = self.ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.ttl_nav { val.validate()? }
		if let Some(ref val) = self.prvs_ttl_nav { val.validate()? }
		if let Some(ref val) = self.ttl_units_nb { val.validate()? }
		if let Some(ref val) = self.prvs_ttl_units_nb { val.validate()? }
		Ok(())
	}
}


// FundBalance1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FundBalance1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlUnitsFrUnitOrdrs", skip_serializing_if = "Option::is_none") )]
	pub ttl_units_fr_unit_ordrs: Option<FinancialInstrumentQuantity1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlUnitsFrCshOrdrs", skip_serializing_if = "Option::is_none") )]
	pub ttl_units_fr_csh_ordrs: Option<FinancialInstrumentQuantity1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlCshFrUnitOrdrs", skip_serializing_if = "Option::is_none") )]
	pub ttl_csh_fr_unit_ordrs: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlCshFrCshOrdrs", skip_serializing_if = "Option::is_none") )]
	pub ttl_csh_fr_csh_ordrs: Option<ActiveOrHistoricCurrencyAndAmount>,
}

impl FundBalance1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ttl_units_fr_unit_ordrs { val.validate()? }
		if let Some(ref val) = self.ttl_units_fr_csh_ordrs { val.validate()? }
		if let Some(ref val) = self.ttl_csh_fr_unit_ordrs { val.validate()? }
		if let Some(ref val) = self.ttl_csh_fr_csh_ordrs { val.validate()? }
		Ok(())
	}
}


// FundCashAccount4Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum FundCashAccount4Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "HEDG") )]
	CodeHEDG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CPFO") )]
	CodeCPFO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CPFS") )]
	CodeCPFS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SRSA") )]
	CodeSRSA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CSDO") )]
	CodeCSDO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TOFF") )]
	CodeTOFF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ICSA") )]
	CodeICSA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CSDM") )]
	CodeCSDM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CSDP") )]
	CodeCSDP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PPEN") )]
	CodePPEN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CPEN") )]
	CodeCPEN,
}

impl FundCashAccount4Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// FundCashForecast6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FundCashForecast6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradDtTm") )]
	pub trad_dt_tm: DateAndDateTimeChoice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsTradDtTm", skip_serializing_if = "Option::is_none") )]
	pub prvs_trad_dt_tm: Option<DateAndDateTimeChoice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmDtls") )]
	pub fin_instrm_dtls: FinancialInstrument9,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNAV", skip_serializing_if = "Option::is_none") )]
	pub ttl_nav: Option<Vec<ActiveOrHistoricCurrencyAndAmount>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsTtlNAV", skip_serializing_if = "Option::is_none") )]
	pub prvs_ttl_nav: Option<Vec<ActiveOrHistoricCurrencyAndAmount>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlUnitsNb", skip_serializing_if = "Option::is_none") )]
	pub ttl_units_nb: Option<FinancialInstrumentQuantity1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsTtlUnitsNb", skip_serializing_if = "Option::is_none") )]
	pub prvs_ttl_units_nb: Option<FinancialInstrumentQuantity1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNAVChngRate", skip_serializing_if = "Option::is_none") )]
	pub ttl_nav_chng_rate: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstmtCcy", skip_serializing_if = "Option::is_none") )]
	pub invstmt_ccy: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CcySts", skip_serializing_if = "Option::is_none") )]
	pub ccy_sts: Option<CurrencyDesignation1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XcptnlNetCshFlowInd") )]
	pub xcptnl_net_csh_flow_ind: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pric", skip_serializing_if = "Option::is_none") )]
	pub pric: Option<UnitPrice19>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FXRate", skip_serializing_if = "Option::is_none") )]
	pub fx_rate: Option<ForeignExchangeTerms19>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PctgOfShrClssTtlNAV", skip_serializing_if = "Option::is_none") )]
	pub pctg_of_shr_clss_ttl_nav: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BrkdwnByPty", skip_serializing_if = "Option::is_none") )]
	pub brkdwn_by_pty: Option<Vec<BreakdownByParty3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BrkdwnByCtry", skip_serializing_if = "Option::is_none") )]
	pub brkdwn_by_ctry: Option<Vec<BreakdownByCountry2>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BrkdwnByCcy", skip_serializing_if = "Option::is_none") )]
	pub brkdwn_by_ccy: Option<Vec<BreakdownByCurrency2>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BrkdwnByUsrDfndParam", skip_serializing_if = "Option::is_none") )]
	pub brkdwn_by_usr_dfnd_param: Option<Vec<BreakdownByUserDefinedParameter3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NetCshFcstDtls", skip_serializing_if = "Option::is_none") )]
	pub net_csh_fcst_dtls: Option<Vec<NetCashForecast4>>,
}

impl FundCashForecast6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		self.trad_dt_tm.validate()?;
		if let Some(ref val) = self.prvs_trad_dt_tm { val.validate()? }
		self.fin_instrm_dtls.validate()?;
		if let Some(ref vec) = self.ttl_nav { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.prvs_ttl_nav { for item in vec { item.validate()? } }
		if let Some(ref val) = self.ttl_units_nb { val.validate()? }
		if let Some(ref val) = self.prvs_ttl_units_nb { val.validate()? }
		if let Some(ref vec) = self.invstmt_ccy {
			for item in vec {
				let pattern = Regex::new("[A-Z]{3,3}").unwrap();
				if !pattern.is_match(&item) {
					return Err(ValidationError::new(1005, "invstmt_ccy does not match the required pattern".to_string()));
				}
			}
		}
		if let Some(ref val) = self.ccy_sts { val.validate()? }
		if let Some(ref val) = self.pric { val.validate()? }
		if let Some(ref val) = self.fx_rate { val.validate()? }
		if let Some(ref vec) = self.brkdwn_by_pty { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.brkdwn_by_ctry { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.brkdwn_by_ccy { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.brkdwn_by_usr_dfnd_param { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.net_csh_fcst_dtls { for item in vec { item.validate()? } }
		Ok(())
	}
}


// FundCashForecast7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FundCashForecast7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradDtTm") )]
	pub trad_dt_tm: DateAndDateTimeChoice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsTradDtTm", skip_serializing_if = "Option::is_none") )]
	pub prvs_trad_dt_tm: Option<DateAndDateTimeChoice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmDtls") )]
	pub fin_instrm_dtls: FinancialInstrument9,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNAV", skip_serializing_if = "Option::is_none") )]
	pub ttl_nav: Option<Vec<ActiveOrHistoricCurrencyAndAmount>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsTtlNAV", skip_serializing_if = "Option::is_none") )]
	pub prvs_ttl_nav: Option<Vec<ActiveOrHistoricCurrencyAndAmount>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlUnitsNb", skip_serializing_if = "Option::is_none") )]
	pub ttl_units_nb: Option<FinancialInstrumentQuantity1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsTtlUnitsNb", skip_serializing_if = "Option::is_none") )]
	pub prvs_ttl_units_nb: Option<FinancialInstrumentQuantity1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNAVChngRate", skip_serializing_if = "Option::is_none") )]
	pub ttl_nav_chng_rate: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstmtCcy", skip_serializing_if = "Option::is_none") )]
	pub invstmt_ccy: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CcySts", skip_serializing_if = "Option::is_none") )]
	pub ccy_sts: Option<CurrencyDesignation1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XcptnlNetCshFlowInd") )]
	pub xcptnl_net_csh_flow_ind: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pric", skip_serializing_if = "Option::is_none") )]
	pub pric: Option<UnitPrice19>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FXRate", skip_serializing_if = "Option::is_none") )]
	pub fx_rate: Option<ForeignExchangeTerms19>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PctgOfShrClssTtlNAV", skip_serializing_if = "Option::is_none") )]
	pub pctg_of_shr_clss_ttl_nav: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshInFcstDtls", skip_serializing_if = "Option::is_none") )]
	pub csh_in_fcst_dtls: Option<Vec<CashInForecast6>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshOutFcstDtls", skip_serializing_if = "Option::is_none") )]
	pub csh_out_fcst_dtls: Option<Vec<CashOutForecast6>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NetCshFcstDtls", skip_serializing_if = "Option::is_none") )]
	pub net_csh_fcst_dtls: Option<Vec<NetCashForecast4>>,
}

impl FundCashForecast7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		self.trad_dt_tm.validate()?;
		if let Some(ref val) = self.prvs_trad_dt_tm { val.validate()? }
		self.fin_instrm_dtls.validate()?;
		if let Some(ref vec) = self.ttl_nav { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.prvs_ttl_nav { for item in vec { item.validate()? } }
		if let Some(ref val) = self.ttl_units_nb { val.validate()? }
		if let Some(ref val) = self.prvs_ttl_units_nb { val.validate()? }
		if let Some(ref vec) = self.invstmt_ccy {
			for item in vec {
				let pattern = Regex::new("[A-Z]{3,3}").unwrap();
				if !pattern.is_match(&item) {
					return Err(ValidationError::new(1005, "invstmt_ccy does not match the required pattern".to_string()));
				}
			}
		}
		if let Some(ref val) = self.ccy_sts { val.validate()? }
		if let Some(ref val) = self.pric { val.validate()? }
		if let Some(ref val) = self.fx_rate { val.validate()? }
		if let Some(ref vec) = self.csh_in_fcst_dtls { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.csh_out_fcst_dtls { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.net_csh_fcst_dtls { for item in vec { item.validate()? } }
		Ok(())
	}
}


// FundCashInBreakdown3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FundCashInBreakdown3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnitsNb", skip_serializing_if = "Option::is_none") )]
	pub units_nb: Option<FinancialInstrumentQuantity1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NewAmtInd", skip_serializing_if = "Option::is_none") )]
	pub new_amt_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstmtFndTxInTp") )]
	pub invstmt_fnd_tx_in_tp: InvestmentFundTransactionInType1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlOrdrQtyTp") )]
	pub orgnl_ordr_qty_tp: QuantityType1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgDtls", skip_serializing_if = "Option::is_none") )]
	pub chrg_dtls: Option<Vec<Charge26>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ComssnDtls", skip_serializing_if = "Option::is_none") )]
	pub comssn_dtls: Option<Vec<Commission21>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmCcy", skip_serializing_if = "Option::is_none") )]
	pub sttlm_ccy: Option<String>,
}

impl FundCashInBreakdown3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.amt { val.validate()? }
		if let Some(ref val) = self.units_nb { val.validate()? }
		self.invstmt_fnd_tx_in_tp.validate()?;
		self.orgnl_ordr_qty_tp.validate()?;
		if let Some(ref vec) = self.chrg_dtls { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.comssn_dtls { for item in vec { item.validate()? } }
		if let Some(ref val) = self.sttlm_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "sttlm_ccy does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// FundCashOutBreakdown3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FundCashOutBreakdown3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnitsNb", skip_serializing_if = "Option::is_none") )]
	pub units_nb: Option<FinancialInstrumentQuantity1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NewAmtInd", skip_serializing_if = "Option::is_none") )]
	pub new_amt_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstmtFndTxOutTp") )]
	pub invstmt_fnd_tx_out_tp: InvestmentFundTransactionOutType1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlOrdrQtyTp") )]
	pub orgnl_ordr_qty_tp: QuantityType1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgDtls", skip_serializing_if = "Option::is_none") )]
	pub chrg_dtls: Option<Vec<Charge26>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ComssnDtls", skip_serializing_if = "Option::is_none") )]
	pub comssn_dtls: Option<Vec<Commission21>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmCcy", skip_serializing_if = "Option::is_none") )]
	pub sttlm_ccy: Option<String>,
}

impl FundCashOutBreakdown3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.amt { val.validate()? }
		if let Some(ref val) = self.units_nb { val.validate()? }
		self.invstmt_fnd_tx_out_tp.validate()?;
		self.orgnl_ordr_qty_tp.validate()?;
		if let Some(ref vec) = self.chrg_dtls { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.comssn_dtls { for item in vec { item.validate()? } }
		if let Some(ref val) = self.sttlm_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "sttlm_ccy does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// FundConfirmedCashForecastReport3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FundConfirmedCashForecastReport3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FndOrSubFndDtls", skip_serializing_if = "Option::is_none") )]
	pub fnd_or_sub_fnd_dtls: Option<Vec<Fund2>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FndCshFcstDtls", skip_serializing_if = "Option::is_none") )]
	pub fnd_csh_fcst_dtls: Option<Vec<FundCashForecast7>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CnsltdNetCshFcst", skip_serializing_if = "Option::is_none") )]
	pub cnsltd_net_csh_fcst: Option<NetCashForecast3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Xtnsn", skip_serializing_if = "Option::is_none") )]
	pub xtnsn: Option<Vec<Extension1>>,
}

impl FundConfirmedCashForecastReport3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.fnd_or_sub_fnd_dtls { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.fnd_csh_fcst_dtls { for item in vec { item.validate()? } }
		if let Some(ref val) = self.cnsltd_net_csh_fcst { val.validate()? }
		if let Some(ref vec) = self.xtnsn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// FundDetailedConfirmedCashForecastReport3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FundDetailedConfirmedCashForecastReport3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FndOrSubFndDtls", skip_serializing_if = "Option::is_none") )]
	pub fnd_or_sub_fnd_dtls: Option<Fund4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FndCshFcstDtls") )]
	pub fnd_csh_fcst_dtls: Vec<FundCashForecast6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CnsltdNetCshFcst", skip_serializing_if = "Option::is_none") )]
	pub cnsltd_net_csh_fcst: Option<NetCashForecast3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Xtnsn", skip_serializing_if = "Option::is_none") )]
	pub xtnsn: Option<Vec<Extension1>>,
}

impl FundDetailedConfirmedCashForecastReport3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.fnd_or_sub_fnd_dtls { val.validate()? }
		for item in &self.fnd_csh_fcst_dtls { item.validate()? }
		if let Some(ref val) = self.cnsltd_net_csh_fcst { val.validate()? }
		if let Some(ref vec) = self.xtnsn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// FundIntention1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum FundIntention1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "YQUA") )]
	CodeYQUA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NQUA") )]
	CodeNQUA,
}

impl FundIntention1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// FundOrderType10Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum FundOrderType10Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "SUBS") )]
	CodeSUBS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RDIV") )]
	CodeRDIV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REDM") )]
	CodeREDM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RGSV") )]
	CodeRGSV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WIDP") )]
	CodeWIDP,
}

impl FundOrderType10Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// FundOrderType5Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FundOrderType5Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<FundOrderType10Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification36>,
}

impl FundOrderType5Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// FundOwnership1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum FundOwnership1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "YALL") )]
	CodeYALL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NALL") )]
	CodeNALL,
}

impl FundOwnership1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// FundParameters4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FundParameters4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NoCrit", skip_serializing_if = "Option::is_none") )]
	pub no_crit: Option<NoCriteria1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Params", skip_serializing_if = "Option::is_none") )]
	pub params: Option<FundParameters5>,
}

impl FundParameters4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.no_crit { val.validate()? }
		if let Some(ref val) = self.params { val.validate()? }
		Ok(())
	}
}


// FundParameters5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FundParameters5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmDtls", skip_serializing_if = "Option::is_none") )]
	pub fin_instrm_dtls: Option<Vec<FinancialInstrument71>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FndMgmtCpny", skip_serializing_if = "Option::is_none") )]
	pub fnd_mgmt_cpny: Option<Vec<PartyIdentification139>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtFr", skip_serializing_if = "Option::is_none") )]
	pub dt_fr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtryOfDmcl", skip_serializing_if = "Option::is_none") )]
	pub ctry_of_dmcl: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegdDstrbtnCtry", skip_serializing_if = "Option::is_none") )]
	pub regd_dstrbtn_ctry: Option<Vec<String>>,
}

impl FundParameters5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.fin_instrm_dtls { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.fnd_mgmt_cpny { for item in vec { item.validate()? } }
		if let Some(ref val) = self.ctry_of_dmcl {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry_of_dmcl does not match the required pattern".to_string()));
			}
		}
		if let Some(ref vec) = self.regd_dstrbtn_ctry {
			for item in vec {
				let pattern = Regex::new("[A-Z]{2,2}").unwrap();
				if !pattern.is_match(&item) {
					return Err(ValidationError::new(1005, "regd_dstrbtn_ctry does not match the required pattern".to_string()));
				}
			}
		}
		Ok(())
	}
}


// FundParties1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FundParties1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Guarntr", skip_serializing_if = "Option::is_none") )]
	pub guarntr: Option<ContactAttributes5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Audtr", skip_serializing_if = "Option::is_none") )]
	pub audtr: Option<ContactAttributes5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Trstee", skip_serializing_if = "Option::is_none") )]
	pub trstee: Option<ContactAttributes5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrPty", skip_serializing_if = "Option::is_none") )]
	pub othr_pty: Option<Vec<ExtendedParty13>>,
}

impl FundParties1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.guarntr { val.validate()? }
		if let Some(ref val) = self.audtr { val.validate()? }
		if let Some(ref val) = self.trstee { val.validate()? }
		if let Some(ref vec) = self.othr_pty { for item in vec { item.validate()? } }
		Ok(())
	}
}


// FundPaymentType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FundPaymentType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<FundPaymentType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification36>,
}

impl FundPaymentType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// FundPaymentType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum FundPaymentType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "DRAF") )]
	CodeDRAF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CACC") )]
	CodeCACC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CHEQ") )]
	CodeCHEQ,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CRDT") )]
	CodeCRDT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DDEB") )]
	CodeDDEB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CARD") )]
	CodeCARD,
}

impl FundPaymentType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// FundReferenceDataReport5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FundReferenceDataReport5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Vrsn", skip_serializing_if = "Option::is_none") )]
	pub vrsn: Option<MarketPracticeVersion1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AuthrsdPrxy", skip_serializing_if = "Option::is_none") )]
	pub authrsd_prxy: Option<ContactAttributes6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GnlRefDt") )]
	pub gnl_ref_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrgtMktInd", skip_serializing_if = "Option::is_none") )]
	pub trgt_mkt_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExAnteInd", skip_serializing_if = "Option::is_none") )]
	pub ex_ante_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExPstInd", skip_serializing_if = "Option::is_none") )]
	pub ex_pst_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctyId") )]
	pub scty_id: SecurityIdentification47,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FndPties", skip_serializing_if = "Option::is_none") )]
	pub fnd_pties: Option<FundParties1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MainFndOrdrDsk", skip_serializing_if = "Option::is_none") )]
	pub main_fnd_ordr_dsk: Option<OrderDesk1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FndMgmtCpny", skip_serializing_if = "Option::is_none") )]
	pub fnd_mgmt_cpny: Option<ContactAttributes5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FndDtls", skip_serializing_if = "Option::is_none") )]
	pub fnd_dtls: Option<FinancialInstrument96>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValtnDealgChrtcs", skip_serializing_if = "Option::is_none") )]
	pub valtn_dealg_chrtcs: Option<ValuationDealingProcessingCharacteristics3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstmtRstrctns", skip_serializing_if = "Option::is_none") )]
	pub invstmt_rstrctns: Option<InvestmentRestrictions3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SbcptPrcgChrtcs", skip_serializing_if = "Option::is_none") )]
	pub sbcpt_prcg_chrtcs: Option<ProcessingCharacteristics11>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RedPrcgChrtcs", skip_serializing_if = "Option::is_none") )]
	pub red_prcg_chrtcs: Option<ProcessingCharacteristics12>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SwtchPrcgChrtcs", skip_serializing_if = "Option::is_none") )]
	pub swtch_prcg_chrtcs: Option<ProcessingCharacteristics9>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PlanChrtcs", skip_serializing_if = "Option::is_none") )]
	pub plan_chrtcs: Option<Vec<InvestmentPlanCharacteristics1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtInstrm", skip_serializing_if = "Option::is_none") )]
	pub pmt_instrm: Option<Vec<PaymentInstrument16>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshSttlmDtls", skip_serializing_if = "Option::is_none") )]
	pub csh_sttlm_dtls: Option<Vec<CashAccount205>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LclMktAnx", skip_serializing_if = "Option::is_none") )]
	pub lcl_mkt_anx: Option<Vec<LocalMarketAnnex6>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrgtMkt", skip_serializing_if = "Option::is_none") )]
	pub trgt_mkt: Option<TargetMarket4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DstrbtnStrtgy", skip_serializing_if = "Option::is_none") )]
	pub dstrbtn_strtgy: Option<DistributionStrategy1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CostsAndChrgs", skip_serializing_if = "Option::is_none") )]
	pub costs_and_chrgs: Option<Vec<CostsAndCharges2>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInfUKMkt", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf_uk_mkt: Option<AdditionalProductInformation3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValForMny", skip_serializing_if = "Option::is_none") )]
	pub val_for_mny: Option<ValueForMoney1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Xtnsn", skip_serializing_if = "Option::is_none") )]
	pub xtnsn: Option<Vec<Extension1>>,
}

impl FundReferenceDataReport5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.vrsn { val.validate()? }
		if let Some(ref val) = self.authrsd_prxy { val.validate()? }
		self.scty_id.validate()?;
		if let Some(ref val) = self.fnd_pties { val.validate()? }
		if let Some(ref val) = self.main_fnd_ordr_dsk { val.validate()? }
		if let Some(ref val) = self.fnd_mgmt_cpny { val.validate()? }
		if let Some(ref val) = self.fnd_dtls { val.validate()? }
		if let Some(ref val) = self.valtn_dealg_chrtcs { val.validate()? }
		if let Some(ref val) = self.invstmt_rstrctns { val.validate()? }
		if let Some(ref val) = self.sbcpt_prcg_chrtcs { val.validate()? }
		if let Some(ref val) = self.red_prcg_chrtcs { val.validate()? }
		if let Some(ref val) = self.swtch_prcg_chrtcs { val.validate()? }
		if let Some(ref vec) = self.plan_chrtcs { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.pmt_instrm { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.csh_sttlm_dtls { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.lcl_mkt_anx { for item in vec { item.validate()? } }
		if let Some(ref val) = self.trgt_mkt { val.validate()? }
		if let Some(ref val) = self.dstrbtn_strtgy { val.validate()? }
		if let Some(ref vec) = self.costs_and_chrgs { for item in vec { item.validate()? } }
		if let Some(ref val) = self.addtl_inf_uk_mkt { val.validate()? }
		if let Some(ref val) = self.val_for_mny { val.validate()? }
		if let Some(ref vec) = self.xtnsn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// FundType2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum FundType2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ETFT") )]
	CodeETFT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MMFT") )]
	CodeMMFT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REIT") )]
	CodeREIT,
}

impl FundType2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// FundingSource3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct FundingSource3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: FundingSourceType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktVal") )]
	pub mkt_val: AmountAndDirection53,
}

impl FundingSource3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tp.validate()?;
		self.mkt_val.validate()?;
		Ok(())
	}
}


// FundingSourceType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum FundingSourceType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "SECL") )]
	CodeSECL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FREE") )]
	CodeFREE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BSHS") )]
	CodeBSHS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CSHS") )]
	CodeCSHS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REPO") )]
	CodeREPO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UBOR") )]
	CodeUBOR,
}

impl FundingSourceType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Future4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Future4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctSz", skip_serializing_if = "Option::is_none") )]
	pub ctrct_sz: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExrcPric", skip_serializing_if = "Option::is_none") )]
	pub exrc_pric: Option<Price8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FutrDt", skip_serializing_if = "Option::is_none") )]
	pub futr_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MinSz", skip_serializing_if = "Option::is_none") )]
	pub min_sz: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnitOfMeasr", skip_serializing_if = "Option::is_none") )]
	pub unit_of_measr: Option<UnitOfMeasure7Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TmUnit", skip_serializing_if = "Option::is_none") )]
	pub tm_unit: Option<TimeUnit3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlUndrlygAttrbts", skip_serializing_if = "Option::is_none") )]
	pub addtl_undrlyg_attrbts: Option<Vec<UnderlyingAttributes4>>,
}

impl Future4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.exrc_pric { val.validate()? }
		if let Some(ref val) = self.min_sz { val.validate()? }
		if let Some(ref val) = self.unit_of_measr { val.validate()? }
		if let Some(ref val) = self.tm_unit { val.validate()? }
		if let Some(ref vec) = self.addtl_undrlyg_attrbts { for item in vec { item.validate()? } }
		Ok(())
	}
}


// GDPRData1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GDPRData1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CnsntTp") )]
	pub cnsnt_tp: GDPRDataConsent1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CnsntInd") )]
	pub cnsnt_ind: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CnsntDt") )]
	pub cnsnt_dt: String,
}

impl GDPRData1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.cnsnt_tp.validate()?;
		Ok(())
	}
}


// GDPRDataConsent1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GDPRDataConsent1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<GDPRDataConsent1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl GDPRDataConsent1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// GDPRDataConsent1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum GDPRDataConsent1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "DP00") )]
	CodeDP00,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DP03") )]
	CodeDP03,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DP01") )]
	CodeDP01,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DP02") )]
	CodeDP02,
}

impl GDPRDataConsent1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Garnishment3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Garnishment3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: GarnishmentType1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Grnshee", skip_serializing_if = "Option::is_none") )]
	pub grnshee: Option<PartyIdentification135>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GrnshmtAdmstr", skip_serializing_if = "Option::is_none") )]
	pub grnshmt_admstr: Option<PartyIdentification135>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RefNb", skip_serializing_if = "Option::is_none") )]
	pub ref_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dt", skip_serializing_if = "Option::is_none") )]
	pub dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RmtdAmt", skip_serializing_if = "Option::is_none") )]
	pub rmtd_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FmlyMdclInsrncInd", skip_serializing_if = "Option::is_none") )]
	pub fmly_mdcl_insrnc_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MplyeeTermntnInd", skip_serializing_if = "Option::is_none") )]
	pub mplyee_termntn_ind: Option<bool>,
}

impl Garnishment3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tp.validate()?;
		if let Some(ref val) = self.grnshee { val.validate()? }
		if let Some(ref val) = self.grnshmt_admstr { val.validate()? }
		if let Some(ref val) = self.ref_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ref_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "ref_nb exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.rmtd_amt { val.validate()? }
		Ok(())
	}
}


// Garnishment4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Garnishment4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: GarnishmentType1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Grnshee", skip_serializing_if = "Option::is_none") )]
	pub grnshee: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GrnshmtAdmstr", skip_serializing_if = "Option::is_none") )]
	pub grnshmt_admstr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RefNb", skip_serializing_if = "Option::is_none") )]
	pub ref_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dt", skip_serializing_if = "Option::is_none") )]
	pub dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RmtdAmt", skip_serializing_if = "Option::is_none") )]
	pub rmtd_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FmlyMdclInsrncInd", skip_serializing_if = "Option::is_none") )]
	pub fmly_mdcl_insrnc_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MplyeeTermntnInd", skip_serializing_if = "Option::is_none") )]
	pub mplyee_termntn_ind: Option<bool>,
}

impl Garnishment4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tp.validate()?;
		if let Some(ref val) = self.grnshee { val.validate()? }
		if let Some(ref val) = self.grnshmt_admstr { val.validate()? }
		if let Some(ref val) = self.ref_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ref_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "ref_nb exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.rmtd_amt { val.validate()? }
		Ok(())
	}
}


// GarnishmentType1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GarnishmentType1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdOrPrtry") )]
	pub cd_or_prtry: GarnishmentType1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issr", skip_serializing_if = "Option::is_none") )]
	pub issr: Option<String>,
}

impl GarnishmentType1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.cd_or_prtry.validate()?;
		if let Some(ref val) = self.issr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "issr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "issr exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// GarnishmentType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GarnishmentType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl GarnishmentType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// Gender1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum Gender1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "FEMA") )]
	CodeFEMA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MALE") )]
	CodeMALE,
}

impl Gender1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// GenderCode ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum GenderCode {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "MALE") )]
	CodeMALE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FEMA") )]
	CodeFEMA,
}

impl GenderCode {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// GeneralBusinessInformation1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GeneralBusinessInformation1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Qlfr", skip_serializing_if = "Option::is_none") )]
	pub qlfr: Option<InformationQualifierType1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sbjt", skip_serializing_if = "Option::is_none") )]
	pub sbjt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SbjtDtls", skip_serializing_if = "Option::is_none") )]
	pub sbjt_dtls: Option<String>,
}

impl GeneralBusinessInformation1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.qlfr { val.validate()? }
		if let Some(ref val) = self.sbjt {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "sbjt is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "sbjt exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.sbjt_dtls {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "sbjt_dtls is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "sbjt_dtls exceeds the maximum length of 350".to_string()));
			}
		}
		Ok(())
	}
}


// GeneralBusinessInformationCriteriaDefinition1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GeneralBusinessInformationCriteriaDefinition1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "QryNm", skip_serializing_if = "Option::is_none") )]
	pub qry_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NewCrit", skip_serializing_if = "Option::is_none") )]
	pub new_crit: Option<BusinessInformationCriteria1>,
}

impl GeneralBusinessInformationCriteriaDefinition1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.qry_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "qry_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "qry_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.new_crit { val.validate()? }
		Ok(())
	}
}


// GeneralBusinessInformationReturnCriteria1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GeneralBusinessInformationReturnCriteria1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "QlfrInd", skip_serializing_if = "Option::is_none") )]
	pub qlfr_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SbjtInd", skip_serializing_if = "Option::is_none") )]
	pub sbjt_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SbjtDtlsInd", skip_serializing_if = "Option::is_none") )]
	pub sbjt_dtls_ind: Option<bool>,
}

impl GeneralBusinessInformationReturnCriteria1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// GeneralBusinessInformationSearchCriteria1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GeneralBusinessInformationSearchCriteria1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ref", skip_serializing_if = "Option::is_none") )]
	pub ref_attr: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sbjt", skip_serializing_if = "Option::is_none") )]
	pub sbjt: Option<Vec<CharacterSearch1Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Qlfr", skip_serializing_if = "Option::is_none") )]
	pub qlfr: Option<Vec<InformationQualifierType1>>,
}

impl GeneralBusinessInformationSearchCriteria1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.ref_attr {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "ref_attr is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 35 {
					return Err(ValidationError::new(1002, "ref_attr exceeds the maximum length of 35".to_string()));
				}
			}
		}
		if let Some(ref vec) = self.sbjt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.qlfr { for item in vec { item.validate()? } }
		Ok(())
	}
}


// GeneralBusinessOrError7Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GeneralBusinessOrError7Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OprlErr", skip_serializing_if = "Option::is_none") )]
	pub oprl_err: Option<Vec<ErrorHandling5>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizRpt", skip_serializing_if = "Option::is_none") )]
	pub biz_rpt: Option<Vec<GeneralBusinessReport6>>,
}

impl GeneralBusinessOrError7Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.oprl_err { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.biz_rpt { for item in vec { item.validate()? } }
		Ok(())
	}
}


// GeneralBusinessOrError8Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GeneralBusinessOrError8Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizErr", skip_serializing_if = "Option::is_none") )]
	pub biz_err: Option<Vec<ErrorHandling5>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GnlBiz", skip_serializing_if = "Option::is_none") )]
	pub gnl_biz: Option<GeneralBusinessInformation1>,
}

impl GeneralBusinessOrError8Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.biz_err { for item in vec { item.validate()? } }
		if let Some(ref val) = self.gnl_biz { val.validate()? }
		Ok(())
	}
}


// GeneralBusinessReport6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GeneralBusinessReport6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizInfRef") )]
	pub biz_inf_ref: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GnlBizOrErr") )]
	pub gnl_biz_or_err: GeneralBusinessOrError8Choice,
}

impl GeneralBusinessReport6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.biz_inf_ref.chars().count() < 1 {
			return Err(ValidationError::new(1001, "biz_inf_ref is shorter than the minimum length of 1".to_string()));
		}
		if self.biz_inf_ref.chars().count() > 35 {
			return Err(ValidationError::new(1002, "biz_inf_ref exceeds the maximum length of 35".to_string()));
		}
		self.gnl_biz_or_err.validate()?;
		Ok(())
	}
}


// GeneralCollateral2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GeneralCollateral2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ElgblFinInstrmId") )]
	pub elgbl_fin_instrm_id: Vec<String>,
}

impl GeneralCollateral2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		for item in &self.elgbl_fin_instrm_id {
			if item.chars().count() < 1 {
				return Err(ValidationError::new(1001, "elgbl_fin_instrm_id is shorter than the minimum length of 1".to_string()));
			}
			if item.chars().count() > 35 {
				return Err(ValidationError::new(1002, "elgbl_fin_instrm_id exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// GeneralCollateral3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GeneralCollateral3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmId", skip_serializing_if = "Option::is_none") )]
	pub fin_instrm_id: Option<Vec<FinancialInstrument59>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ElgblFinInstrmId", skip_serializing_if = "Option::is_none") )]
	pub elgbl_fin_instrm_id: Option<Vec<String>>,
}

impl GeneralCollateral3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.fin_instrm_id { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.elgbl_fin_instrm_id {
			for item in vec {
				let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
				if !pattern.is_match(&item) {
					return Err(ValidationError::new(1005, "elgbl_fin_instrm_id does not match the required pattern".to_string()));
				}
			}
		}
		Ok(())
	}
}


// GeneralCollateral4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GeneralCollateral4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmId", skip_serializing_if = "Option::is_none") )]
	pub fin_instrm_id: Option<Vec<FinancialInstrument104>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktVal") )]
	pub mkt_val: ActiveCurrencyAnd24Amount,
}

impl GeneralCollateral4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.fin_instrm_id { for item in vec { item.validate()? } }
		self.mkt_val.validate()?;
		Ok(())
	}
}


// GenericAccountIdentification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GenericAccountIdentification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SchmeNm", skip_serializing_if = "Option::is_none") )]
	pub schme_nm: Option<AccountSchemeName1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issr", skip_serializing_if = "Option::is_none") )]
	pub issr: Option<String>,
}

impl GenericAccountIdentification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 34 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 34".to_string()));
		}
		if let Some(ref val) = self.schme_nm { val.validate()? }
		if let Some(ref val) = self.issr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "issr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "issr exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// GenericFinancialIdentification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GenericFinancialIdentification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SchmeNm", skip_serializing_if = "Option::is_none") )]
	pub schme_nm: Option<FinancialIdentificationSchemeName1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issr", skip_serializing_if = "Option::is_none") )]
	pub issr: Option<String>,
}

impl GenericFinancialIdentification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.schme_nm { val.validate()? }
		if let Some(ref val) = self.issr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "issr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "issr exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// GenericIdentification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GenericIdentification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SchmeNm", skip_serializing_if = "Option::is_none") )]
	pub schme_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issr", skip_serializing_if = "Option::is_none") )]
	pub issr: Option<String>,
}

impl GenericIdentification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.schme_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "schme_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "schme_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.issr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "issr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "issr exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// GenericIdentification13 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GenericIdentification13 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SchmeNm", skip_serializing_if = "Option::is_none") )]
	pub schme_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issr") )]
	pub issr: String,
}

impl GenericIdentification13 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 4 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 4".to_string()));
		}
		let pattern = Regex::new("[a-zA-Z0-9]{1,4}").unwrap();
		if !pattern.is_match(&self.id) {
			return Err(ValidationError::new(1005, "id does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.schme_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "schme_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "schme_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if self.issr.chars().count() < 1 {
			return Err(ValidationError::new(1001, "issr is shorter than the minimum length of 1".to_string()));
		}
		if self.issr.chars().count() > 35 {
			return Err(ValidationError::new(1002, "issr exceeds the maximum length of 35".to_string()));
		}
		Ok(())
	}
}


// GenericIdentification165 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GenericIdentification165 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Desc", skip_serializing_if = "Option::is_none") )]
	pub desc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issr", skip_serializing_if = "Option::is_none") )]
	pub issr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SchmeNm", skip_serializing_if = "Option::is_none") )]
	pub schme_nm: Option<SchemeIdentificationType1Code>,
}

impl GenericIdentification165 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 256 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 256".to_string()));
		}
		if let Some(ref val) = self.desc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "desc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "desc exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.issr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "issr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "issr exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.schme_nm { val.validate()? }
		Ok(())
	}
}


// GenericIdentification168 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GenericIdentification168 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Desc", skip_serializing_if = "Option::is_none") )]
	pub desc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issr", skip_serializing_if = "Option::is_none") )]
	pub issr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SchmeNm", skip_serializing_if = "Option::is_none") )]
	pub schme_nm: Option<String>,
}

impl GenericIdentification168 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 256 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 256".to_string()));
		}
		if let Some(ref val) = self.desc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "desc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "desc exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.issr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "issr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "issr exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.schme_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "schme_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "schme_nm exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// GenericIdentification175 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GenericIdentification175 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SchmeNm", skip_serializing_if = "Option::is_none") )]
	pub schme_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issr", skip_serializing_if = "Option::is_none") )]
	pub issr: Option<String>,
}

impl GenericIdentification175 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 72 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 72".to_string()));
		}
		if let Some(ref val) = self.schme_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "schme_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "schme_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.issr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "issr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "issr exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// GenericIdentification179 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GenericIdentification179 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issr", skip_serializing_if = "Option::is_none") )]
	pub issr: Option<String>,
}

impl GenericIdentification179 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 52 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 52".to_string()));
		}
		if let Some(ref val) = self.issr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "issr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "issr exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// GenericIdentification184 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GenericIdentification184 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Src") )]
	pub src: String,
}

impl GenericIdentification184 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 210 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 210".to_string()));
		}
		if self.src.chars().count() < 1 {
			return Err(ValidationError::new(1001, "src is shorter than the minimum length of 1".to_string()));
		}
		if self.src.chars().count() > 100 {
			return Err(ValidationError::new(1002, "src exceeds the maximum length of 100".to_string()));
		}
		Ok(())
	}
}


// GenericIdentification185 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GenericIdentification185 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SchmeNm", skip_serializing_if = "Option::is_none") )]
	pub schme_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issr", skip_serializing_if = "Option::is_none") )]
	pub issr: Option<String>,
}

impl GenericIdentification185 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 100 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 100".to_string()));
		}
		if let Some(ref val) = self.schme_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "schme_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "schme_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.issr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "issr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "issr exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// GenericIdentification3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GenericIdentification3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issr", skip_serializing_if = "Option::is_none") )]
	pub issr: Option<String>,
}

impl GenericIdentification3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.issr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "issr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "issr exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// GenericIdentification30 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GenericIdentification30 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issr") )]
	pub issr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SchmeNm", skip_serializing_if = "Option::is_none") )]
	pub schme_nm: Option<String>,
}

impl GenericIdentification30 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[a-zA-Z0-9]{4}").unwrap();
		if !pattern.is_match(&self.id) {
			return Err(ValidationError::new(1005, "id does not match the required pattern".to_string()));
		}
		if self.issr.chars().count() < 1 {
			return Err(ValidationError::new(1001, "issr is shorter than the minimum length of 1".to_string()));
		}
		if self.issr.chars().count() > 35 {
			return Err(ValidationError::new(1002, "issr exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.schme_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "schme_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "schme_nm exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// GenericIdentification32 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GenericIdentification32 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<PartyType3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issr", skip_serializing_if = "Option::is_none") )]
	pub issr: Option<PartyType4Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ShrtNm", skip_serializing_if = "Option::is_none") )]
	pub shrt_nm: Option<String>,
}

impl GenericIdentification32 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.issr { val.validate()? }
		if let Some(ref val) = self.shrt_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "shrt_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "shrt_nm exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// GenericIdentification36 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GenericIdentification36 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issr") )]
	pub issr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SchmeNm", skip_serializing_if = "Option::is_none") )]
	pub schme_nm: Option<String>,
}

impl GenericIdentification36 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		if self.issr.chars().count() < 1 {
			return Err(ValidationError::new(1001, "issr is shorter than the minimum length of 1".to_string()));
		}
		if self.issr.chars().count() > 35 {
			return Err(ValidationError::new(1002, "issr exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.schme_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "schme_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "schme_nm exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// GenericIdentification37 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GenericIdentification37 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issr", skip_serializing_if = "Option::is_none") )]
	pub issr: Option<String>,
}

impl GenericIdentification37 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.issr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "issr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "issr exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// GenericIdentification44 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GenericIdentification44 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: OtherIdentification1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issr", skip_serializing_if = "Option::is_none") )]
	pub issr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IsseDt", skip_serializing_if = "Option::is_none") )]
	pub isse_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XpryDt", skip_serializing_if = "Option::is_none") )]
	pub xpry_dt: Option<String>,
}

impl GenericIdentification44 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		self.tp.validate()?;
		if let Some(ref val) = self.issr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "issr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "issr exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// GenericIdentification47 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GenericIdentification47 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issr") )]
	pub issr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SchmeNm", skip_serializing_if = "Option::is_none") )]
	pub schme_nm: Option<String>,
}

impl GenericIdentification47 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[a-zA-Z0-9]{4}").unwrap();
		if !pattern.is_match(&self.id) {
			return Err(ValidationError::new(1005, "id does not match the required pattern".to_string()));
		}
		if self.issr.chars().count() < 1 {
			return Err(ValidationError::new(1001, "issr is shorter than the minimum length of 1".to_string()));
		}
		if self.issr.chars().count() > 4 {
			return Err(ValidationError::new(1002, "issr exceeds the maximum length of 4".to_string()));
		}
		let pattern = Regex::new("[a-zA-Z0-9]{1,4}").unwrap();
		if !pattern.is_match(&self.issr) {
			return Err(ValidationError::new(1005, "issr does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.schme_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "schme_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "schme_nm exceeds the maximum length of 4".to_string()));
			}
			let pattern = Regex::new("[a-zA-Z0-9]{1,4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "schme_nm does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// GenericIdentification49 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GenericIdentification49 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IdTp") )]
	pub id_tp: String,
}

impl GenericIdentification49 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		if self.id_tp.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id_tp is shorter than the minimum length of 1".to_string()));
		}
		if self.id_tp.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id_tp exceeds the maximum length of 35".to_string()));
		}
		Ok(())
	}
}


// GenericIdentification81 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GenericIdentification81 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IdTp") )]
	pub id_tp: OtherIdentification3Choice,
}

impl GenericIdentification81 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		self.id_tp.validate()?;
		Ok(())
	}
}


// GenericIdentification82 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GenericIdentification82 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: OtherIdentification3Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issr", skip_serializing_if = "Option::is_none") )]
	pub issr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IsseDt", skip_serializing_if = "Option::is_none") )]
	pub isse_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XpryDt", skip_serializing_if = "Option::is_none") )]
	pub xpry_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Stat", skip_serializing_if = "Option::is_none") )]
	pub stat: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IssrCtry", skip_serializing_if = "Option::is_none") )]
	pub issr_ctry: Option<String>,
}

impl GenericIdentification82 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		self.tp.validate()?;
		if let Some(ref val) = self.issr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "issr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "issr exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.stat {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "stat is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "stat exceeds the maximum length of 70".to_string()));
			}
		}
		if let Some(ref val) = self.issr_ctry {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "issr_ctry does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// GenericOrganisationIdentification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GenericOrganisationIdentification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SchmeNm", skip_serializing_if = "Option::is_none") )]
	pub schme_nm: Option<OrganisationIdentificationSchemeName1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issr", skip_serializing_if = "Option::is_none") )]
	pub issr: Option<String>,
}

impl GenericOrganisationIdentification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.schme_nm { val.validate()? }
		if let Some(ref val) = self.issr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "issr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "issr exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// GenericOrganisationIdentification3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GenericOrganisationIdentification3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SchmeNm", skip_serializing_if = "Option::is_none") )]
	pub schme_nm: Option<OrganisationIdentificationSchemeName1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issr", skip_serializing_if = "Option::is_none") )]
	pub issr: Option<String>,
}

impl GenericOrganisationIdentification3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 256 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 256".to_string()));
		}
		if let Some(ref val) = self.schme_nm { val.validate()? }
		if let Some(ref val) = self.issr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "issr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "issr exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// GenericOrganisationType1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GenericOrganisationType1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Reqd") )]
	pub reqd: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SchmeNm") )]
	pub schme_nm: OrganisationIdentificationSchemeName1Choice,
}

impl GenericOrganisationType1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.schme_nm.validate()?;
		Ok(())
	}
}


// GenericPersonIdentification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GenericPersonIdentification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SchmeNm", skip_serializing_if = "Option::is_none") )]
	pub schme_nm: Option<PersonIdentificationSchemeName1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issr", skip_serializing_if = "Option::is_none") )]
	pub issr: Option<String>,
}

impl GenericPersonIdentification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.schme_nm { val.validate()? }
		if let Some(ref val) = self.issr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "issr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "issr exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// GenericPersonIdentification2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GenericPersonIdentification2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SchmeNm", skip_serializing_if = "Option::is_none") )]
	pub schme_nm: Option<PersonIdentificationSchemeName1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issr", skip_serializing_if = "Option::is_none") )]
	pub issr: Option<String>,
}

impl GenericPersonIdentification2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 256 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 256".to_string()));
		}
		if let Some(ref val) = self.schme_nm { val.validate()? }
		if let Some(ref val) = self.issr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "issr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "issr exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// GenericPersonType1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GenericPersonType1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Reqd") )]
	pub reqd: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SchmeNm") )]
	pub schme_nm: PersonIdentificationSchemeName1Choice,
}

impl GenericPersonType1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.schme_nm.validate()?;
		Ok(())
	}
}


// GenericValidationRuleIdentification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GenericValidationRuleIdentification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Desc", skip_serializing_if = "Option::is_none") )]
	pub desc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SchmeNm", skip_serializing_if = "Option::is_none") )]
	pub schme_nm: Option<ValidationRuleSchemeName1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issr", skip_serializing_if = "Option::is_none") )]
	pub issr: Option<String>,
}

impl GenericValidationRuleIdentification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.desc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "desc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "desc exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.schme_nm { val.validate()? }
		if let Some(ref val) = self.issr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "issr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "issr exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// GlobalNote1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum GlobalNote1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "NGNO") )]
	CodeNGNO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CGNO") )]
	CodeCGNO,
}

impl GlobalNote1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// GlobalNote2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GlobalNote2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<GlobalNote1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl GlobalNote2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// GovernanceProcess1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GovernanceProcess1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<GovernanceProcessType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl GovernanceProcess1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// GovernanceProcessType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum GovernanceProcessType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "BMIF") )]
	CodeBMIF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NINF") )]
	CodeNINF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CMIF") )]
	CodeCMIF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AMIF") )]
	CodeAMIF,
}

impl GovernanceProcessType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Group5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Group5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModCd", skip_serializing_if = "Option::is_none") )]
	pub mod_cd: Option<Modification1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GrpId") )]
	pub grp_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pty") )]
	pub pty: Vec<PartyAndCertificate7>,
}

impl Group5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mod_cd { val.validate()? }
		if self.grp_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "grp_id is shorter than the minimum length of 1".to_string()));
		}
		if self.grp_id.chars().count() > 4 {
			return Err(ValidationError::new(1002, "grp_id exceeds the maximum length of 4".to_string()));
		}
		let pattern = Regex::new("[a-zA-Z0-9]{1,4}").unwrap();
		if !pattern.is_match(&self.grp_id) {
			return Err(ValidationError::new(1005, "grp_id does not match the required pattern".to_string()));
		}
		for item in &self.pty { item.validate()? }
		Ok(())
	}
}


// Group6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Group6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "GrpId") )]
	pub grp_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pty") )]
	pub pty: Vec<PartyAndCertificate6>,
}

impl Group6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.grp_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "grp_id is shorter than the minimum length of 1".to_string()));
		}
		if self.grp_id.chars().count() > 4 {
			return Err(ValidationError::new(1002, "grp_id exceeds the maximum length of 4".to_string()));
		}
		let pattern = Regex::new("[a-zA-Z0-9]{1,4}").unwrap();
		if !pattern.is_match(&self.grp_id) {
			return Err(ValidationError::new(1005, "grp_id does not match the required pattern".to_string()));
		}
		for item in &self.pty { item.validate()? }
		Ok(())
	}
}


// GroupCancellationStatus1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum GroupCancellationStatus1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "PACR") )]
	CodePACR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RJCR") )]
	CodeRJCR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACCR") )]
	CodeACCR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PDCR") )]
	CodePDCR,
}

impl GroupCancellationStatus1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// GroupHeader101 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GroupHeader101 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm") )]
	pub cre_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstgAgt", skip_serializing_if = "Option::is_none") )]
	pub instg_agt: Option<BranchAndFinancialInstitutionIdentification6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstdAgt", skip_serializing_if = "Option::is_none") )]
	pub instd_agt: Option<BranchAndFinancialInstitutionIdentification6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlBizQry", skip_serializing_if = "Option::is_none") )]
	pub orgnl_biz_qry: Option<OriginalBusinessQuery1>,
}

impl GroupHeader101 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.instg_agt { val.validate()? }
		if let Some(ref val) = self.instd_agt { val.validate()? }
		if let Some(ref val) = self.orgnl_biz_qry { val.validate()? }
		Ok(())
	}
}


// GroupHeader103 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GroupHeader103 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm") )]
	pub cre_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfChqs") )]
	pub nb_of_chqs: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrlSum", skip_serializing_if = "Option::is_none") )]
	pub ctrl_sum: Option<f64>,
}

impl GroupHeader103 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		let pattern = Regex::new("[0-9]{1,15}").unwrap();
		if !pattern.is_match(&self.nb_of_chqs) {
			return Err(ValidationError::new(1005, "nb_of_chqs does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// GroupHeader104 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GroupHeader104 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm") )]
	pub cre_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfSttlmReqs") )]
	pub nb_of_sttlm_reqs: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrlSum", skip_serializing_if = "Option::is_none") )]
	pub ctrl_sum: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmInf", skip_serializing_if = "Option::is_none") )]
	pub sttlm_inf: Option<SettlementInstruction14>,
}

impl GroupHeader104 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		let pattern = Regex::new("[0-9]{1,15}").unwrap();
		if !pattern.is_match(&self.nb_of_sttlm_reqs) {
			return Err(ValidationError::new(1005, "nb_of_sttlm_reqs does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.sttlm_inf { val.validate()? }
		Ok(())
	}
}


// GroupHeader109 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GroupHeader109 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm") )]
	pub cre_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstgAgt", skip_serializing_if = "Option::is_none") )]
	pub instg_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstdAgt", skip_serializing_if = "Option::is_none") )]
	pub instd_agt: Option<BranchAndFinancialInstitutionIdentification8>,
}

impl GroupHeader109 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.instg_agt { val.validate()? }
		if let Some(ref val) = self.instd_agt { val.validate()? }
		Ok(())
	}
}


// GroupHeader110 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GroupHeader110 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm") )]
	pub cre_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Authstn", skip_serializing_if = "Option::is_none") )]
	pub authstn: Option<Vec<Authorisation1Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitgPty", skip_serializing_if = "Option::is_none") )]
	pub initg_pty: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstgAgt", skip_serializing_if = "Option::is_none") )]
	pub instg_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstdAgt", skip_serializing_if = "Option::is_none") )]
	pub instd_agt: Option<BranchAndFinancialInstitutionIdentification8>,
}

impl GroupHeader110 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref vec) = self.authstn { for item in vec { item.validate()? } }
		if let Some(ref val) = self.initg_pty { val.validate()? }
		if let Some(ref val) = self.instg_agt { val.validate()? }
		if let Some(ref val) = self.instd_agt { val.validate()? }
		Ok(())
	}
}


// GroupHeader111 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GroupHeader111 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm") )]
	pub cre_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitgPty") )]
	pub initg_pty: PartyIdentification272,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FwdgAgt", skip_serializing_if = "Option::is_none") )]
	pub fwdg_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgt", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgt", skip_serializing_if = "Option::is_none") )]
	pub cdtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
}

impl GroupHeader111 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		self.initg_pty.validate()?;
		if let Some(ref val) = self.fwdg_agt { val.validate()? }
		if let Some(ref val) = self.dbtr_agt { val.validate()? }
		if let Some(ref val) = self.cdtr_agt { val.validate()? }
		Ok(())
	}
}


// GroupHeader112 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GroupHeader112 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm") )]
	pub cre_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfTxs") )]
	pub nb_of_txs: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrlSum", skip_serializing_if = "Option::is_none") )]
	pub ctrl_sum: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitgPty") )]
	pub initg_pty: PartyIdentification272,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FwdgAgt", skip_serializing_if = "Option::is_none") )]
	pub fwdg_agt: Option<BranchAndFinancialInstitutionIdentification8>,
}

impl GroupHeader112 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		let pattern = Regex::new("[0-9]{1,15}").unwrap();
		if !pattern.is_match(&self.nb_of_txs) {
			return Err(ValidationError::new(1005, "nb_of_txs does not match the required pattern".to_string()));
		}
		self.initg_pty.validate()?;
		if let Some(ref val) = self.fwdg_agt { val.validate()? }
		Ok(())
	}
}


// GroupHeader113 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GroupHeader113 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm") )]
	pub cre_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BtchBookg", skip_serializing_if = "Option::is_none") )]
	pub btch_bookg: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfTxs") )]
	pub nb_of_txs: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrlSum", skip_serializing_if = "Option::is_none") )]
	pub ctrl_sum: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlIntrBkSttlmAmt", skip_serializing_if = "Option::is_none") )]
	pub ttl_intr_bk_sttlm_amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBkSttlmDt", skip_serializing_if = "Option::is_none") )]
	pub intr_bk_sttlm_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmInf") )]
	pub sttlm_inf: SettlementInstruction15,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtTpInf", skip_serializing_if = "Option::is_none") )]
	pub pmt_tp_inf: Option<PaymentTypeInformation28>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstgAgt", skip_serializing_if = "Option::is_none") )]
	pub instg_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstdAgt", skip_serializing_if = "Option::is_none") )]
	pub instd_agt: Option<BranchAndFinancialInstitutionIdentification8>,
}

impl GroupHeader113 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		let pattern = Regex::new("[0-9]{1,15}").unwrap();
		if !pattern.is_match(&self.nb_of_txs) {
			return Err(ValidationError::new(1005, "nb_of_txs does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.ttl_intr_bk_sttlm_amt { val.validate()? }
		self.sttlm_inf.validate()?;
		if let Some(ref val) = self.pmt_tp_inf { val.validate()? }
		if let Some(ref val) = self.instg_agt { val.validate()? }
		if let Some(ref val) = self.instd_agt { val.validate()? }
		Ok(())
	}
}


// GroupHeader114 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GroupHeader114 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm") )]
	pub cre_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Authstn", skip_serializing_if = "Option::is_none") )]
	pub authstn: Option<Vec<Authorisation1Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfTxs") )]
	pub nb_of_txs: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrlSum", skip_serializing_if = "Option::is_none") )]
	pub ctrl_sum: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitgPty") )]
	pub initg_pty: PartyIdentification272,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FwdgAgt", skip_serializing_if = "Option::is_none") )]
	pub fwdg_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitnSrc", skip_serializing_if = "Option::is_none") )]
	pub initn_src: Option<PaymentInitiationSource1>,
}

impl GroupHeader114 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref vec) = self.authstn { for item in vec { item.validate()? } }
		let pattern = Regex::new("[0-9]{1,15}").unwrap();
		if !pattern.is_match(&self.nb_of_txs) {
			return Err(ValidationError::new(1005, "nb_of_txs does not match the required pattern".to_string()));
		}
		self.initg_pty.validate()?;
		if let Some(ref val) = self.fwdg_agt { val.validate()? }
		if let Some(ref val) = self.initn_src { val.validate()? }
		Ok(())
	}
}


// GroupHeader115 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GroupHeader115 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm") )]
	pub cre_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsRqstr", skip_serializing_if = "Option::is_none") )]
	pub chrgs_rqstr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlChrgs", skip_serializing_if = "Option::is_none") )]
	pub ttl_chrgs: Option<TotalCharges7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsAcctAgt", skip_serializing_if = "Option::is_none") )]
	pub chrgs_acct_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsAcctAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub chrgs_acct_agt_acct: Option<CashAccount40>,
}

impl GroupHeader115 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.chrgs_rqstr { val.validate()? }
		if let Some(ref val) = self.ttl_chrgs { val.validate()? }
		if let Some(ref val) = self.chrgs_acct_agt { val.validate()? }
		if let Some(ref val) = self.chrgs_acct_agt_acct { val.validate()? }
		Ok(())
	}
}


// GroupHeader116 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GroupHeader116 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm") )]
	pub cre_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgRcpt", skip_serializing_if = "Option::is_none") )]
	pub msg_rcpt: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgPgntn", skip_serializing_if = "Option::is_none") )]
	pub msg_pgntn: Option<Pagination1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlBizQry", skip_serializing_if = "Option::is_none") )]
	pub orgnl_biz_qry: Option<OriginalBusinessQuery1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
}

impl GroupHeader116 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.msg_rcpt { val.validate()? }
		if let Some(ref val) = self.msg_pgntn { val.validate()? }
		if let Some(ref val) = self.orgnl_biz_qry { val.validate()? }
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 500 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 500".to_string()));
			}
		}
		Ok(())
	}
}


// GroupHeader117 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GroupHeader117 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm") )]
	pub cre_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgSndr", skip_serializing_if = "Option::is_none") )]
	pub msg_sndr: Option<Party50Choice>,
}

impl GroupHeader117 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.msg_sndr { val.validate()? }
		Ok(())
	}
}


// GroupHeader118 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GroupHeader118 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm") )]
	pub cre_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Authstn", skip_serializing_if = "Option::is_none") )]
	pub authstn: Option<Vec<Authorisation1Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfTxs") )]
	pub nb_of_txs: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrlSum", skip_serializing_if = "Option::is_none") )]
	pub ctrl_sum: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitgPty") )]
	pub initg_pty: PartyIdentification272,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FwdgAgt", skip_serializing_if = "Option::is_none") )]
	pub fwdg_agt: Option<BranchAndFinancialInstitutionIdentification8>,
}

impl GroupHeader118 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref vec) = self.authstn { for item in vec { item.validate()? } }
		let pattern = Regex::new("[0-9]{1,15}").unwrap();
		if !pattern.is_match(&self.nb_of_txs) {
			return Err(ValidationError::new(1005, "nb_of_txs does not match the required pattern".to_string()));
		}
		self.initg_pty.validate()?;
		if let Some(ref val) = self.fwdg_agt { val.validate()? }
		Ok(())
	}
}


// GroupHeader119 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GroupHeader119 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm") )]
	pub cre_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfTxs") )]
	pub nb_of_txs: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrlSum", skip_serializing_if = "Option::is_none") )]
	pub ctrl_sum: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstgAgt", skip_serializing_if = "Option::is_none") )]
	pub instg_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstdAgt", skip_serializing_if = "Option::is_none") )]
	pub instd_agt: Option<BranchAndFinancialInstitutionIdentification8>,
}

impl GroupHeader119 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		let pattern = Regex::new("[0-9]{1,15}").unwrap();
		if !pattern.is_match(&self.nb_of_txs) {
			return Err(ValidationError::new(1005, "nb_of_txs does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.instg_agt { val.validate()? }
		if let Some(ref val) = self.instd_agt { val.validate()? }
		Ok(())
	}
}


// GroupHeader120 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GroupHeader120 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm") )]
	pub cre_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstgAgt", skip_serializing_if = "Option::is_none") )]
	pub instg_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstdAgt", skip_serializing_if = "Option::is_none") )]
	pub instd_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlBizQry", skip_serializing_if = "Option::is_none") )]
	pub orgnl_biz_qry: Option<OriginalBusinessQuery1>,
}

impl GroupHeader120 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.instg_agt { val.validate()? }
		if let Some(ref val) = self.instd_agt { val.validate()? }
		if let Some(ref val) = self.orgnl_biz_qry { val.validate()? }
		Ok(())
	}
}


// GroupHeader121 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GroupHeader121 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm") )]
	pub cre_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgRcpt", skip_serializing_if = "Option::is_none") )]
	pub msg_rcpt: Option<Party50Choice>,
}

impl GroupHeader121 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.msg_rcpt { val.validate()? }
		Ok(())
	}
}


// GroupHeader122 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GroupHeader122 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm") )]
	pub cre_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Authstn", skip_serializing_if = "Option::is_none") )]
	pub authstn: Option<Vec<Authorisation1Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CpyInd", skip_serializing_if = "Option::is_none") )]
	pub cpy_ind: Option<CopyDuplicate1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitgPty") )]
	pub initg_pty: PartyIdentification272,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgRcpt", skip_serializing_if = "Option::is_none") )]
	pub msg_rcpt: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FwdgAgt", skip_serializing_if = "Option::is_none") )]
	pub fwdg_agt: Option<BranchAndFinancialInstitutionIdentification8>,
}

impl GroupHeader122 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref vec) = self.authstn { for item in vec { item.validate()? } }
		if let Some(ref val) = self.cpy_ind { val.validate()? }
		self.initg_pty.validate()?;
		if let Some(ref val) = self.msg_rcpt { val.validate()? }
		if let Some(ref val) = self.fwdg_agt { val.validate()? }
		Ok(())
	}
}


// GroupHeader123 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GroupHeader123 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm") )]
	pub cre_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Authstn", skip_serializing_if = "Option::is_none") )]
	pub authstn: Option<Vec<Authorisation1Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BtchBookg", skip_serializing_if = "Option::is_none") )]
	pub btch_bookg: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfTxs") )]
	pub nb_of_txs: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrlSum", skip_serializing_if = "Option::is_none") )]
	pub ctrl_sum: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GrpRtr", skip_serializing_if = "Option::is_none") )]
	pub grp_rtr: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlRtrdIntrBkSttlmAmt", skip_serializing_if = "Option::is_none") )]
	pub ttl_rtrd_intr_bk_sttlm_amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBkSttlmDt", skip_serializing_if = "Option::is_none") )]
	pub intr_bk_sttlm_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmInf") )]
	pub sttlm_inf: SettlementInstruction15,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtTpInf", skip_serializing_if = "Option::is_none") )]
	pub pmt_tp_inf: Option<PaymentTypeInformation28>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstgAgt", skip_serializing_if = "Option::is_none") )]
	pub instg_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstdAgt", skip_serializing_if = "Option::is_none") )]
	pub instd_agt: Option<BranchAndFinancialInstitutionIdentification8>,
}

impl GroupHeader123 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref vec) = self.authstn { for item in vec { item.validate()? } }
		let pattern = Regex::new("[0-9]{1,15}").unwrap();
		if !pattern.is_match(&self.nb_of_txs) {
			return Err(ValidationError::new(1005, "nb_of_txs does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.ttl_rtrd_intr_bk_sttlm_amt { val.validate()? }
		self.sttlm_inf.validate()?;
		if let Some(ref val) = self.pmt_tp_inf { val.validate()? }
		if let Some(ref val) = self.instg_agt { val.validate()? }
		if let Some(ref val) = self.instd_agt { val.validate()? }
		Ok(())
	}
}


// GroupHeader124 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GroupHeader124 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm") )]
	pub cre_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Authstn", skip_serializing_if = "Option::is_none") )]
	pub authstn: Option<Vec<Authorisation1Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfTxs") )]
	pub nb_of_txs: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrlSum", skip_serializing_if = "Option::is_none") )]
	pub ctrl_sum: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GrpRvsl", skip_serializing_if = "Option::is_none") )]
	pub grp_rvsl: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitgPty", skip_serializing_if = "Option::is_none") )]
	pub initg_pty: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FwdgAgt", skip_serializing_if = "Option::is_none") )]
	pub fwdg_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgt", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgt", skip_serializing_if = "Option::is_none") )]
	pub cdtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
}

impl GroupHeader124 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref vec) = self.authstn { for item in vec { item.validate()? } }
		let pattern = Regex::new("[0-9]{1,15}").unwrap();
		if !pattern.is_match(&self.nb_of_txs) {
			return Err(ValidationError::new(1005, "nb_of_txs does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.initg_pty { val.validate()? }
		if let Some(ref val) = self.fwdg_agt { val.validate()? }
		if let Some(ref val) = self.dbtr_agt { val.validate()? }
		if let Some(ref val) = self.cdtr_agt { val.validate()? }
		Ok(())
	}
}


// GroupHeader125 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GroupHeader125 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm") )]
	pub cre_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Authstn", skip_serializing_if = "Option::is_none") )]
	pub authstn: Option<Vec<Authorisation1Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BtchBookg", skip_serializing_if = "Option::is_none") )]
	pub btch_bookg: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfTxs") )]
	pub nb_of_txs: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrlSum", skip_serializing_if = "Option::is_none") )]
	pub ctrl_sum: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlIntrBkSttlmAmt", skip_serializing_if = "Option::is_none") )]
	pub ttl_intr_bk_sttlm_amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBkSttlmDt", skip_serializing_if = "Option::is_none") )]
	pub intr_bk_sttlm_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmInf") )]
	pub sttlm_inf: SettlementInstruction14,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtTpInf", skip_serializing_if = "Option::is_none") )]
	pub pmt_tp_inf: Option<PaymentTypeInformation27>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstgAgt", skip_serializing_if = "Option::is_none") )]
	pub instg_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstdAgt", skip_serializing_if = "Option::is_none") )]
	pub instd_agt: Option<BranchAndFinancialInstitutionIdentification8>,
}

impl GroupHeader125 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref vec) = self.authstn { for item in vec { item.validate()? } }
		let pattern = Regex::new("[0-9]{1,15}").unwrap();
		if !pattern.is_match(&self.nb_of_txs) {
			return Err(ValidationError::new(1005, "nb_of_txs does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.ttl_intr_bk_sttlm_amt { val.validate()? }
		self.sttlm_inf.validate()?;
		if let Some(ref val) = self.pmt_tp_inf { val.validate()? }
		if let Some(ref val) = self.instg_agt { val.validate()? }
		if let Some(ref val) = self.instd_agt { val.validate()? }
		Ok(())
	}
}


// GroupHeader126 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GroupHeader126 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm") )]
	pub cre_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsRqstr", skip_serializing_if = "Option::is_none") )]
	pub chrgs_rqstr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlChrgs", skip_serializing_if = "Option::is_none") )]
	pub ttl_chrgs: Option<TotalCharges7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsAcct", skip_serializing_if = "Option::is_none") )]
	pub chrgs_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsAcctOwnr", skip_serializing_if = "Option::is_none") )]
	pub chrgs_acct_ownr: Option<BranchAndFinancialInstitutionIdentification8>,
}

impl GroupHeader126 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.chrgs_rqstr { val.validate()? }
		if let Some(ref val) = self.ttl_chrgs { val.validate()? }
		if let Some(ref val) = self.chrgs_acct { val.validate()? }
		if let Some(ref val) = self.chrgs_acct_ownr { val.validate()? }
		Ok(())
	}
}


// GroupHeader127 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GroupHeader127 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm") )]
	pub cre_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Authstn", skip_serializing_if = "Option::is_none") )]
	pub authstn: Option<Vec<Authorisation1Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BtchBookg", skip_serializing_if = "Option::is_none") )]
	pub btch_bookg: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfTxs") )]
	pub nb_of_txs: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrlSum", skip_serializing_if = "Option::is_none") )]
	pub ctrl_sum: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GrpRvsl", skip_serializing_if = "Option::is_none") )]
	pub grp_rvsl: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlRvsdIntrBkSttlmAmt", skip_serializing_if = "Option::is_none") )]
	pub ttl_rvsd_intr_bk_sttlm_amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBkSttlmDt", skip_serializing_if = "Option::is_none") )]
	pub intr_bk_sttlm_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmInf") )]
	pub sttlm_inf: SettlementInstruction15,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstgAgt", skip_serializing_if = "Option::is_none") )]
	pub instg_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstdAgt", skip_serializing_if = "Option::is_none") )]
	pub instd_agt: Option<BranchAndFinancialInstitutionIdentification8>,
}

impl GroupHeader127 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref vec) = self.authstn { for item in vec { item.validate()? } }
		let pattern = Regex::new("[0-9]{1,15}").unwrap();
		if !pattern.is_match(&self.nb_of_txs) {
			return Err(ValidationError::new(1005, "nb_of_txs does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.ttl_rvsd_intr_bk_sttlm_amt { val.validate()? }
		self.sttlm_inf.validate()?;
		if let Some(ref val) = self.instg_agt { val.validate()? }
		if let Some(ref val) = self.instd_agt { val.validate()? }
		Ok(())
	}
}


// GroupHeader128 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GroupHeader128 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm") )]
	pub cre_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitgPty", skip_serializing_if = "Option::is_none") )]
	pub initg_pty: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FwdgAgt", skip_serializing_if = "Option::is_none") )]
	pub fwdg_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgt", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgt", skip_serializing_if = "Option::is_none") )]
	pub cdtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
}

impl GroupHeader128 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.initg_pty { val.validate()? }
		if let Some(ref val) = self.fwdg_agt { val.validate()? }
		if let Some(ref val) = self.dbtr_agt { val.validate()? }
		if let Some(ref val) = self.cdtr_agt { val.validate()? }
		Ok(())
	}
}


// GroupHeader129 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GroupHeader129 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm") )]
	pub cre_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sndr") )]
	pub sndr: Party50Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rcvr") )]
	pub rcvr: Party50Choice,
}

impl GroupHeader129 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		self.sndr.validate()?;
		self.rcvr.validate()?;
		Ok(())
	}
}


// GroupHeader69 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct GroupHeader69 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IssdDt") )]
	pub issd_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptCtgy") )]
	pub rpt_ctgy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxRptPurp") )]
	pub tax_rpt_purp: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SellrTaxRprtv", skip_serializing_if = "Option::is_none") )]
	pub sellr_tax_rprtv: Option<PartyIdentification116>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BuyrTaxRprtv", skip_serializing_if = "Option::is_none") )]
	pub buyr_tax_rprtv: Option<PartyIdentification116>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LangCd", skip_serializing_if = "Option::is_none") )]
	pub lang_cd: Option<String>,
}

impl GroupHeader69 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		if self.rpt_ctgy.chars().count() < 1 {
			return Err(ValidationError::new(1001, "rpt_ctgy is shorter than the minimum length of 1".to_string()));
		}
		if self.rpt_ctgy.chars().count() > 4 {
			return Err(ValidationError::new(1002, "rpt_ctgy exceeds the maximum length of 4".to_string()));
		}
		if self.tax_rpt_purp.chars().count() < 1 {
			return Err(ValidationError::new(1001, "tax_rpt_purp is shorter than the minimum length of 1".to_string()));
		}
		if self.tax_rpt_purp.chars().count() > 4 {
			return Err(ValidationError::new(1002, "tax_rpt_purp exceeds the maximum length of 4".to_string()));
		}
		if let Some(ref val) = self.orgnl_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.sellr_tax_rprtv { val.validate()? }
		if let Some(ref val) = self.buyr_tax_rprtv { val.validate()? }
		Ok(())
	}
}


// Guarantee1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Guarantee1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prvdr") )]
	pub prvdr: PartyIdentification118Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveCurrencyAndAmount,
}

impl Guarantee1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.prvdr.validate()?;
		self.amt.validate()?;
		Ok(())
	}
}


// HighFrequencyTradingProfile1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct HighFrequencyTradingProfile1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dt", skip_serializing_if = "Option::is_none") )]
	pub dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmFrqcy", skip_serializing_if = "Option::is_none") )]
	pub sttlm_frqcy: Option<SettlementFrequency1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CnsldtnTp", skip_serializing_if = "Option::is_none") )]
	pub cnsldtn_tp: Option<ConsolidationType1Choice>,
}

impl HighFrequencyTradingProfile1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.sttlm_frqcy { val.validate()? }
		if let Some(ref val) = self.cnsldtn_tp { val.validate()? }
		Ok(())
	}
}


// Holding1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum Holding1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CERT") )]
	CodeCERT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NPRH") )]
	CodeNPRH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRTH") )]
	CodePRTH,
}

impl Holding1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// HoldingTransferable1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum HoldingTransferable1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "TRAL") )]
	CodeTRAL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TRNA") )]
	CodeTRNA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RFOD") )]
	CodeRFOD,
}

impl HoldingTransferable1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// HypotheticalCapitalMeasure1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct HypotheticalCapitalMeasure1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DfltWtrfllId") )]
	pub dflt_wtrfll_id: String,
}

impl HypotheticalCapitalMeasure1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.amt.validate()?;
		if self.dflt_wtrfll_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "dflt_wtrfll_id is shorter than the minimum length of 1".to_string()));
		}
		if self.dflt_wtrfll_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "dflt_wtrfll_id exceeds the maximum length of 35".to_string()));
		}
		Ok(())
	}
}


// ISINQueryCriteria1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ISINQueryCriteria1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Idr", skip_serializing_if = "Option::is_none") )]
	pub idr: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NotRptd", skip_serializing_if = "Option::is_none") )]
	pub not_rptd: Option<NotReported1Code>,
}

impl ISINQueryCriteria1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.idr {
			for item in vec {
				let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
				if !pattern.is_match(&item) {
					return Err(ValidationError::new(1005, "idr does not match the required pattern".to_string()));
				}
			}
		}
		if let Some(ref val) = self.not_rptd { val.validate()? }
		Ok(())
	}
}


// IdentificationAssignment4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IdentificationAssignment4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm") )]
	pub cre_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cretr", skip_serializing_if = "Option::is_none") )]
	pub cretr: Option<Party50Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrstAgt", skip_serializing_if = "Option::is_none") )]
	pub frst_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Assgnr") )]
	pub assgnr: Party50Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Assgne") )]
	pub assgne: Party50Choice,
}

impl IdentificationAssignment4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.cretr { val.validate()? }
		if let Some(ref val) = self.frst_agt { val.validate()? }
		self.assgnr.validate()?;
		self.assgne.validate()?;
		Ok(())
	}
}


// IdentificationInformation5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IdentificationInformation5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pty", skip_serializing_if = "Option::is_none") )]
	pub pty: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Acct", skip_serializing_if = "Option::is_none") )]
	pub acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Agt", skip_serializing_if = "Option::is_none") )]
	pub agt: Option<BranchAndFinancialInstitutionIdentification8>,
}

impl IdentificationInformation5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.pty { val.validate()? }
		if let Some(ref val) = self.acct { val.validate()? }
		if let Some(ref val) = self.agt { val.validate()? }
		Ok(())
	}
}


// IdentificationModification5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IdentificationModification5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlPtyAndAcctId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_pty_and_acct_id: Option<IdentificationInformation5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UpdtdPtyAndAcctId") )]
	pub updtd_pty_and_acct_id: IdentificationInformation5,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
}

impl IdentificationModification5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.orgnl_pty_and_acct_id { val.validate()? }
		self.updtd_pty_and_acct_id.validate()?;
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// IdentificationSource1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IdentificationSource1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dmst", skip_serializing_if = "Option::is_none") )]
	pub dmst: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl IdentificationSource1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.dmst {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "dmst does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// IdentificationSource3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IdentificationSource3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl IdentificationSource3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// IdentificationSource5Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IdentificationSource5Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DmstIdSrc", skip_serializing_if = "Option::is_none") )]
	pub dmst_id_src: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtryIdSrc", skip_serializing_if = "Option::is_none") )]
	pub prtry_id_src: Option<String>,
}

impl IdentificationSource5Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.dmst_id_src {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "dmst_id_src does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.prtry_id_src {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry_id_src is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry_id_src exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// IdentificationVerification5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IdentificationVerification5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtyAndAcctId") )]
	pub pty_and_acct_id: IdentificationInformation5,
}

impl IdentificationVerification5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		self.pty_and_acct_id.validate()?;
		Ok(())
	}
}


// ImplementationSpecification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ImplementationSpecification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Regy") )]
	pub regy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
}

impl ImplementationSpecification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.regy.chars().count() < 1 {
			return Err(ValidationError::new(1001, "regy is shorter than the minimum length of 1".to_string()));
		}
		if self.regy.chars().count() > 350 {
			return Err(ValidationError::new(1002, "regy exceeds the maximum length of 350".to_string()));
		}
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 2048 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 2048".to_string()));
		}
		Ok(())
	}
}


// ImpliedCurrencyAmountRange1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ImpliedCurrencyAmountRange1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrAmt", skip_serializing_if = "Option::is_none") )]
	pub fr_amt: Option<AmountRangeBoundary1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ToAmt", skip_serializing_if = "Option::is_none") )]
	pub to_amt: Option<AmountRangeBoundary1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrToAmt", skip_serializing_if = "Option::is_none") )]
	pub fr_to_amt: Option<FromToAmountRange1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EQAmt", skip_serializing_if = "Option::is_none") )]
	pub eq_amt: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NEQAmt", skip_serializing_if = "Option::is_none") )]
	pub neq_amt: Option<f64>,
}

impl ImpliedCurrencyAmountRange1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.fr_amt { val.validate()? }
		if let Some(ref val) = self.to_amt { val.validate()? }
		if let Some(ref val) = self.fr_to_amt { val.validate()? }
		if let Some(ref val) = self.eq_amt {
			if *val < 0.000000 {
				return Err(ValidationError::new(1003, "eq_amt is less than the minimum value of 0.000000".to_string()));
			}
		}
		if let Some(ref val) = self.neq_amt {
			if *val < 0.000000 {
				return Err(ValidationError::new(1003, "neq_amt is less than the minimum value of 0.000000".to_string()));
			}
		}
		Ok(())
	}
}


// ImpliedCurrencyAndAmountRange1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ImpliedCurrencyAndAmountRange1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ImpliedCurrencyAmountRange1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbtInd", skip_serializing_if = "Option::is_none") )]
	pub cdt_dbt_ind: Option<CreditDebitCode>,
}

impl ImpliedCurrencyAndAmountRange1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.amt.validate()?;
		if let Some(ref val) = self.cdt_dbt_ind { val.validate()? }
		Ok(())
	}
}


// IncomePreference2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum IncomePreference2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CASH") )]
	CodeCASH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SECU") )]
	CodeSECU,
}

impl IncomePreference2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// IncomeStatement1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IncomeStatement1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrFees") )]
	pub clr_fees: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrOprgRvn") )]
	pub othr_oprg_rvn: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OprgExpnss") )]
	pub oprg_expnss: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OprgPrftOrLoss") )]
	pub oprg_prft_or_loss: AmountAndDirection102,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NetIntrstIncm") )]
	pub net_intrst_incm: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrNonOprgRvn") )]
	pub othr_non_oprg_rvn: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NonOprgExpnss") )]
	pub non_oprg_expnss: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PreTaxPrftOrLoss") )]
	pub pre_tax_prft_or_loss: AmountAndDirection102,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstTaxPrftOrLoss") )]
	pub pst_tax_prft_or_loss: AmountAndDirection102,
}

impl IncomeStatement1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.clr_fees.validate()?;
		self.othr_oprg_rvn.validate()?;
		self.oprg_expnss.validate()?;
		self.oprg_prft_or_loss.validate()?;
		self.net_intrst_incm.validate()?;
		self.othr_non_oprg_rvn.validate()?;
		self.non_oprg_expnss.validate()?;
		self.pre_tax_prft_or_loss.validate()?;
		self.pst_tax_prft_or_loss.validate()?;
		Ok(())
	}
}


// IncorrectData1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IncorrectData1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl IncorrectData1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// IndexIdentification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IndexIdentification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISIN", skip_serializing_if = "Option::is_none") )]
	pub isin: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Indx", skip_serializing_if = "Option::is_none") )]
	pub indx: Option<String>,
}

impl IndexIdentification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.isin {
			let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "isin does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.indx {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "indx is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "indx exceeds the maximum length of 4".to_string()));
			}
		}
		Ok(())
	}
}


// IndividualCostOrCharge2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IndividualCostOrCharge2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CostTp") )]
	pub cost_tp: ChargeType8Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExAnteOrExPst") )]
	pub ex_ante_or_ex_pst: IntendedOrActual2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<ActiveCurrencyAnd13DecimalAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sgn", skip_serializing_if = "Option::is_none") )]
	pub sgn: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rate", skip_serializing_if = "Option::is_none") )]
	pub rate: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RefPrd", skip_serializing_if = "Option::is_none") )]
	pub ref_prd: Option<Period15>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<AdditionalInformation15>,
}

impl IndividualCostOrCharge2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.cost_tp.validate()?;
		self.ex_ante_or_ex_pst.validate()?;
		if let Some(ref val) = self.amt { val.validate()? }
		if let Some(ref val) = self.ref_prd { val.validate()? }
		if let Some(ref val) = self.addtl_inf { val.validate()? }
		Ok(())
	}
}


// IndividualPerson29 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IndividualPerson29 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NmPrfx", skip_serializing_if = "Option::is_none") )]
	pub nm_prfx: Option<NamePrefix1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GvnNm", skip_serializing_if = "Option::is_none") )]
	pub gvn_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MddlNm", skip_serializing_if = "Option::is_none") )]
	pub mddl_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm") )]
	pub nm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstlAdr") )]
	pub pstl_adr: Vec<PostalAddress21>,
}

impl IndividualPerson29 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nm_prfx { val.validate()? }
		if let Some(ref val) = self.gvn_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "gvn_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "gvn_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.mddl_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mddl_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "mddl_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if self.nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
		}
		if self.nm.chars().count() > 350 {
			return Err(ValidationError::new(1002, "nm exceeds the maximum length of 350".to_string()));
		}
		for item in &self.pstl_adr { item.validate()? }
		Ok(())
	}
}


// IndividualPerson30 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IndividualPerson30 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "GvnNm", skip_serializing_if = "Option::is_none") )]
	pub gvn_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MddlNm", skip_serializing_if = "Option::is_none") )]
	pub mddl_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm") )]
	pub nm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Gndr", skip_serializing_if = "Option::is_none") )]
	pub gndr: Option<GenderCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BirthDt", skip_serializing_if = "Option::is_none") )]
	pub birth_dt: Option<String>,
}

impl IndividualPerson30 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.gvn_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "gvn_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "gvn_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.mddl_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mddl_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "mddl_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if self.nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
		}
		if self.nm.chars().count() > 350 {
			return Err(ValidationError::new(1002, "nm exceeds the maximum length of 350".to_string()));
		}
		if let Some(ref val) = self.gndr { val.validate()? }
		Ok(())
	}
}


// IndividualPerson35 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IndividualPerson35 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "GvnNm", skip_serializing_if = "Option::is_none") )]
	pub gvn_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MddlNm", skip_serializing_if = "Option::is_none") )]
	pub mddl_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm") )]
	pub nm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Gndr", skip_serializing_if = "Option::is_none") )]
	pub gndr: Option<Gender1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BirthDt", skip_serializing_if = "Option::is_none") )]
	pub birth_dt: Option<String>,
}

impl IndividualPerson35 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.gvn_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "gvn_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "gvn_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.mddl_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mddl_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "mddl_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if self.nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
		}
		if self.nm.chars().count() > 350 {
			return Err(ValidationError::new(1002, "nm exceeds the maximum length of 350".to_string()));
		}
		if let Some(ref val) = self.gndr { val.validate()? }
		Ok(())
	}
}


// IndividualPerson37 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IndividualPerson37 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NmPrfx", skip_serializing_if = "Option::is_none") )]
	pub nm_prfx: Option<NamePrefix1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GvnNm", skip_serializing_if = "Option::is_none") )]
	pub gvn_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MddlNm", skip_serializing_if = "Option::is_none") )]
	pub mddl_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm") )]
	pub nm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NmSfx", skip_serializing_if = "Option::is_none") )]
	pub nm_sfx: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Gndr", skip_serializing_if = "Option::is_none") )]
	pub gndr: Option<Gender1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BirthDt", skip_serializing_if = "Option::is_none") )]
	pub birth_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtryOfBirth", skip_serializing_if = "Option::is_none") )]
	pub ctry_of_birth: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvcOfBirth", skip_serializing_if = "Option::is_none") )]
	pub prvc_of_birth: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CityOfBirth", skip_serializing_if = "Option::is_none") )]
	pub city_of_birth: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prfssn", skip_serializing_if = "Option::is_none") )]
	pub prfssn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstlAdr") )]
	pub pstl_adr: Vec<PostalAddress21>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctznsh", skip_serializing_if = "Option::is_none") )]
	pub ctznsh: Option<Vec<CitizenshipInformation2>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EmplngCpny", skip_serializing_if = "Option::is_none") )]
	pub emplng_cpny: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizFctn", skip_serializing_if = "Option::is_none") )]
	pub biz_fctn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PltclyXpsdPrsn", skip_serializing_if = "Option::is_none") )]
	pub pltcly_xpsd_prsn: Option<PoliticallyExposedPerson1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DthDt", skip_serializing_if = "Option::is_none") )]
	pub dth_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CvlSts", skip_serializing_if = "Option::is_none") )]
	pub cvl_sts: Option<CivilStatus1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EdctnLvl", skip_serializing_if = "Option::is_none") )]
	pub edctn_lvl: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FmlyInf", skip_serializing_if = "Option::is_none") )]
	pub fmly_inf: Option<PersonalInformation1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GDPRData", skip_serializing_if = "Option::is_none") )]
	pub gdpr_data: Option<Vec<GDPRData1>>,
}

impl IndividualPerson37 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nm_prfx { val.validate()? }
		if let Some(ref val) = self.gvn_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "gvn_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "gvn_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.mddl_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mddl_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "mddl_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if self.nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
		}
		if self.nm.chars().count() > 350 {
			return Err(ValidationError::new(1002, "nm exceeds the maximum length of 350".to_string()));
		}
		if let Some(ref val) = self.nm_sfx {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm_sfx is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "nm_sfx exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.gndr { val.validate()? }
		if let Some(ref val) = self.ctry_of_birth {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry_of_birth does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.prvc_of_birth {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prvc_of_birth is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prvc_of_birth exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.city_of_birth {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "city_of_birth is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "city_of_birth exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.prfssn {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prfssn is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prfssn exceeds the maximum length of 35".to_string()));
			}
		}
		for item in &self.pstl_adr { item.validate()? }
		if let Some(ref vec) = self.ctznsh { for item in vec { item.validate()? } }
		if let Some(ref val) = self.emplng_cpny {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "emplng_cpny is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "emplng_cpny exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.biz_fctn {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "biz_fctn is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "biz_fctn exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.pltcly_xpsd_prsn { val.validate()? }
		if let Some(ref val) = self.cvl_sts { val.validate()? }
		if let Some(ref val) = self.edctn_lvl {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "edctn_lvl is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "edctn_lvl exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.fmly_inf { val.validate()? }
		if let Some(ref vec) = self.gdpr_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// IndividualPerson38 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IndividualPerson38 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NmPrfx", skip_serializing_if = "Option::is_none") )]
	pub nm_prfx: Option<NamePrefix1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GvnNm", skip_serializing_if = "Option::is_none") )]
	pub gvn_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MddlNm", skip_serializing_if = "Option::is_none") )]
	pub mddl_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm") )]
	pub nm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NmSfx", skip_serializing_if = "Option::is_none") )]
	pub nm_sfx: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Gndr", skip_serializing_if = "Option::is_none") )]
	pub gndr: Option<Gender1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BirthDt", skip_serializing_if = "Option::is_none") )]
	pub birth_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtryOfBirth", skip_serializing_if = "Option::is_none") )]
	pub ctry_of_birth: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvcOfBirth", skip_serializing_if = "Option::is_none") )]
	pub prvc_of_birth: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CityOfBirth", skip_serializing_if = "Option::is_none") )]
	pub city_of_birth: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prfssn", skip_serializing_if = "Option::is_none") )]
	pub prfssn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModfdPstlAdr", skip_serializing_if = "Option::is_none") )]
	pub modfd_pstl_adr: Option<Vec<ModificationScope34>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModfdCtznsh", skip_serializing_if = "Option::is_none") )]
	pub modfd_ctznsh: Option<Vec<ModificationScope39>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EmplngCpny", skip_serializing_if = "Option::is_none") )]
	pub emplng_cpny: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizFctn", skip_serializing_if = "Option::is_none") )]
	pub biz_fctn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PltclyXpsdPrsn", skip_serializing_if = "Option::is_none") )]
	pub pltcly_xpsd_prsn: Option<PoliticallyExposedPerson1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DthDt", skip_serializing_if = "Option::is_none") )]
	pub dth_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CvlSts", skip_serializing_if = "Option::is_none") )]
	pub cvl_sts: Option<CivilStatus1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EdctnLvl", skip_serializing_if = "Option::is_none") )]
	pub edctn_lvl: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FmlyInf", skip_serializing_if = "Option::is_none") )]
	pub fmly_inf: Option<PersonalInformation1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GDPRData", skip_serializing_if = "Option::is_none") )]
	pub gdpr_data: Option<Vec<GDPRData1>>,
}

impl IndividualPerson38 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nm_prfx { val.validate()? }
		if let Some(ref val) = self.gvn_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "gvn_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "gvn_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.mddl_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mddl_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "mddl_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if self.nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
		}
		if self.nm.chars().count() > 350 {
			return Err(ValidationError::new(1002, "nm exceeds the maximum length of 350".to_string()));
		}
		if let Some(ref val) = self.nm_sfx {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm_sfx is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "nm_sfx exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.gndr { val.validate()? }
		if let Some(ref val) = self.ctry_of_birth {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry_of_birth does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.prvc_of_birth {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prvc_of_birth is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prvc_of_birth exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.city_of_birth {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "city_of_birth is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "city_of_birth exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.prfssn {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prfssn is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prfssn exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref vec) = self.modfd_pstl_adr { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.modfd_ctznsh { for item in vec { item.validate()? } }
		if let Some(ref val) = self.emplng_cpny {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "emplng_cpny is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "emplng_cpny exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.biz_fctn {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "biz_fctn is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "biz_fctn exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.pltcly_xpsd_prsn { val.validate()? }
		if let Some(ref val) = self.cvl_sts { val.validate()? }
		if let Some(ref val) = self.edctn_lvl {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "edctn_lvl is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "edctn_lvl exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.fmly_inf { val.validate()? }
		if let Some(ref vec) = self.gdpr_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// IndividualPerson44 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IndividualPerson44 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CurNm") )]
	pub cur_nm: IndividualPersonNameLong2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsNm", skip_serializing_if = "Option::is_none") )]
	pub prvs_nm: Option<Vec<IndividualPersonNameLong2>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Gndr", skip_serializing_if = "Option::is_none") )]
	pub gndr: Option<Gender1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Lang", skip_serializing_if = "Option::is_none") )]
	pub lang: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BirthDt", skip_serializing_if = "Option::is_none") )]
	pub birth_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtryOfBirth", skip_serializing_if = "Option::is_none") )]
	pub ctry_of_birth: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvcOfBirth", skip_serializing_if = "Option::is_none") )]
	pub prvc_of_birth: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CityOfBirth", skip_serializing_if = "Option::is_none") )]
	pub city_of_birth: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxtnCtry", skip_serializing_if = "Option::is_none") )]
	pub taxtn_ctry: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtryAndResdtlSts", skip_serializing_if = "Option::is_none") )]
	pub ctry_and_resdtl_sts: Option<CountryAndResidentialStatusType1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SclSctyNb", skip_serializing_if = "Option::is_none") )]
	pub scl_scty_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstlAdr", skip_serializing_if = "Option::is_none") )]
	pub pstl_adr: Option<Vec<PostalAddress27>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtznshInf", skip_serializing_if = "Option::is_none") )]
	pub ctznsh_inf: Option<Vec<CitizenshipInformation1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmryComAdr", skip_serializing_if = "Option::is_none") )]
	pub pmry_com_adr: Option<CommunicationAddress3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ScndryComAdr", skip_serializing_if = "Option::is_none") )]
	pub scndry_com_adr: Option<CommunicationAddress3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrId", skip_serializing_if = "Option::is_none") )]
	pub othr_id: Option<Vec<GenericIdentification44>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrDtls", skip_serializing_if = "Option::is_none") )]
	pub othr_dtls: Option<Vec<TransferInstruction1>>,
}

impl IndividualPerson44 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.cur_nm.validate()?;
		if let Some(ref vec) = self.prvs_nm { for item in vec { item.validate()? } }
		if let Some(ref val) = self.gndr { val.validate()? }
		if let Some(ref val) = self.ctry_of_birth {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry_of_birth does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.prvc_of_birth {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prvc_of_birth is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prvc_of_birth exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.city_of_birth {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "city_of_birth is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "city_of_birth exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.taxtn_ctry {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "taxtn_ctry does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.ctry_and_resdtl_sts { val.validate()? }
		if let Some(ref val) = self.scl_scty_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "scl_scty_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "scl_scty_nb exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref vec) = self.pstl_adr { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.ctznsh_inf { for item in vec { item.validate()? } }
		if let Some(ref val) = self.pmry_com_adr { val.validate()? }
		if let Some(ref val) = self.scndry_com_adr { val.validate()? }
		if let Some(ref vec) = self.othr_id { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.othr_dtls { for item in vec { item.validate()? } }
		Ok(())
	}
}


// IndividualPersonIdentification2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IndividualPersonIdentification2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "IdNb", skip_serializing_if = "Option::is_none") )]
	pub id_nb: Option<GenericIdentification81>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrsnNm", skip_serializing_if = "Option::is_none") )]
	pub prsn_nm: Option<IndividualPerson30>,
}

impl IndividualPersonIdentification2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.id_nb { val.validate()? }
		if let Some(ref val) = self.prsn_nm { val.validate()? }
		Ok(())
	}
}


// IndividualPersonIdentification3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IndividualPersonIdentification3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "IdNb", skip_serializing_if = "Option::is_none") )]
	pub id_nb: Option<GenericIdentification81>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrsnNm", skip_serializing_if = "Option::is_none") )]
	pub prsn_nm: Option<IndividualPerson35>,
}

impl IndividualPersonIdentification3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.id_nb { val.validate()? }
		if let Some(ref val) = self.prsn_nm { val.validate()? }
		Ok(())
	}
}


// IndividualPersonNameLong2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IndividualPersonNameLong2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NmPrfx", skip_serializing_if = "Option::is_none") )]
	pub nm_prfx: Option<NamePrefix2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Srnm") )]
	pub srnm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GvnNm", skip_serializing_if = "Option::is_none") )]
	pub gvn_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MddlNm", skip_serializing_if = "Option::is_none") )]
	pub mddl_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Initls", skip_serializing_if = "Option::is_none") )]
	pub initls: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NmSfx", skip_serializing_if = "Option::is_none") )]
	pub nm_sfx: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StartDt", skip_serializing_if = "Option::is_none") )]
	pub start_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndDt", skip_serializing_if = "Option::is_none") )]
	pub end_dt: Option<String>,
}

impl IndividualPersonNameLong2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nm_prfx { val.validate()? }
		if self.srnm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "srnm is shorter than the minimum length of 1".to_string()));
		}
		if self.srnm.chars().count() > 35 {
			return Err(ValidationError::new(1002, "srnm exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.gvn_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "gvn_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "gvn_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.mddl_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mddl_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "mddl_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.initls {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "initls is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 6 {
				return Err(ValidationError::new(1002, "initls exceeds the maximum length of 6".to_string()));
			}
		}
		if let Some(ref val) = self.nm_sfx {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm_sfx is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "nm_sfx exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 350".to_string()));
			}
		}
		Ok(())
	}
}


// IndustrialProductCommodityConstruction1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IndustrialProductCommodityConstruction1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType6Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType33Code>,
}

impl IndustrialProductCommodityConstruction1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// IndustrialProductCommodityConstruction2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IndustrialProductCommodityConstruction2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType6Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType33Code>,
}

impl IndustrialProductCommodityConstruction2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// IndustrialProductCommodityManufacturing1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IndustrialProductCommodityManufacturing1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType6Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType34Code>,
}

impl IndustrialProductCommodityManufacturing1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// IndustrialProductCommodityManufacturing2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IndustrialProductCommodityManufacturing2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType6Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType34Code>,
}

impl IndustrialProductCommodityManufacturing2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// InflationIndex1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InflationIndex1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISIN", skip_serializing_if = "Option::is_none") )]
	pub isin: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
}

impl InflationIndex1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.isin {
			let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "isin does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 25 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 25".to_string()));
			}
		}
		Ok(())
	}
}


// InformationDistribution1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InformationDistribution1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<InformationDistribution2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl InformationDistribution1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// InformationDistribution2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum InformationDistribution2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ELEC") )]
	CodeELEC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NONE") )]
	CodeNONE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PAPR") )]
	CodePAPR,
}

impl InformationDistribution2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// InformationQualifierType1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InformationQualifierType1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "IsFrmtd", skip_serializing_if = "Option::is_none") )]
	pub is_frmtd: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prty", skip_serializing_if = "Option::is_none") )]
	pub prty: Option<Priority1Code>,
}

impl InformationQualifierType1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.prty { val.validate()? }
		Ok(())
	}
}


// InformationType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InformationType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<InformationType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl InformationType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// InformationType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum InformationType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "INST") )]
	CodeINST,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RELY") )]
	CodeRELY,
}

impl InformationType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// InitialAmount1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InitialAmount1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitlNbOfInstlmts", skip_serializing_if = "Option::is_none") )]
	pub initl_nb_of_instlmts: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<ActiveCurrencyAndAmount>,
}

impl InitialAmount1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.amt { val.validate()? }
		Ok(())
	}
}


// InitialMarginExposure1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InitialMarginExposure1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: Amount3,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: MarginType2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CoreInd") )]
	pub core_ind: bool,
}

impl InitialMarginExposure1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.amt.validate()?;
		self.tp.validate()?;
		Ok(())
	}
}


// InitialMarginRequirement1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InitialMarginRequirement1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitlMrgnXpsr") )]
	pub initl_mrgn_xpsr: Vec<InitialMarginExposure1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cdt") )]
	pub cdt: ActiveCurrencyAndAmount,
}

impl InitialMarginRequirement1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		for item in &self.initl_mrgn_xpsr { item.validate()? }
		self.cdt.validate()?;
		Ok(())
	}
}


// InitialPhysicalForm1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum InitialPhysicalForm1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "GTGT") )]
	CodeGTGT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GPGP") )]
	CodeGPGP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DERN") )]
	CodeDERN,
}

impl InitialPhysicalForm1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// InitialPhysicalForm2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum InitialPhysicalForm2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "GPGP") )]
	CodeGPGP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DERN") )]
	CodeDERN,
}

impl InitialPhysicalForm2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// InitialPhysicalForm3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InitialPhysicalForm3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<InitialPhysicalForm2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl InitialPhysicalForm3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// InitialPhysicalForm4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InitialPhysicalForm4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<InitialPhysicalForm1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl InitialPhysicalForm4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// Instruction1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum Instruction1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "PBEN") )]
	CodePBEN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TTIL") )]
	CodeTTIL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TFRO") )]
	CodeTFRO,
}

impl Instruction1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Instruction4Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum Instruction4Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "PHOA") )]
	CodePHOA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TELA") )]
	CodeTELA,
}

impl Instruction4Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// InstructionForAssignee1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InstructionForAssignee1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrInf", skip_serializing_if = "Option::is_none") )]
	pub instr_inf: Option<String>,
}

impl InstructionForAssignee1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.instr_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "instr_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "instr_inf exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// InstructionForChequeAgent1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InstructionForChequeAgent1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrInf", skip_serializing_if = "Option::is_none") )]
	pub instr_inf: Option<String>,
}

impl InstructionForChequeAgent1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.instr_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "instr_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "instr_inf exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// InstructionForCreditorAgent3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InstructionForCreditorAgent3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrInf", skip_serializing_if = "Option::is_none") )]
	pub instr_inf: Option<String>,
}

impl InstructionForCreditorAgent3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.instr_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "instr_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "instr_inf exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// InstructionForDebtorAgent1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InstructionForDebtorAgent1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrInf", skip_serializing_if = "Option::is_none") )]
	pub instr_inf: Option<String>,
}

impl InstructionForDebtorAgent1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.instr_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "instr_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "instr_inf exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// InstructionForInstructedAgent1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InstructionForInstructedAgent1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrInf", skip_serializing_if = "Option::is_none") )]
	pub instr_inf: Option<String>,
}

impl InstructionForInstructedAgent1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.instr_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "instr_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "instr_inf exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// InstructionForNextAgent1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InstructionForNextAgent1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<Instruction4Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrInf", skip_serializing_if = "Option::is_none") )]
	pub instr_inf: Option<String>,
}

impl InstructionForNextAgent1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.instr_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "instr_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "instr_inf exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// InstructionStatusReturnCriteria1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InstructionStatusReturnCriteria1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtInstrStsInd") )]
	pub pmt_instr_sts_ind: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtInstrStsDtTmInd", skip_serializing_if = "Option::is_none") )]
	pub pmt_instr_sts_dt_tm_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtInstrStsRsnInd", skip_serializing_if = "Option::is_none") )]
	pub pmt_instr_sts_rsn_ind: Option<bool>,
}

impl InstructionStatusReturnCriteria1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// InstructionStatusSearch5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InstructionStatusSearch5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtInstrSts", skip_serializing_if = "Option::is_none") )]
	pub pmt_instr_sts: Option<PaymentStatusCodeSearch2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtInstrStsDtTm", skip_serializing_if = "Option::is_none") )]
	pub pmt_instr_sts_dt_tm: Option<DateTimePeriod1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtryStsRsn", skip_serializing_if = "Option::is_none") )]
	pub prtry_sts_rsn: Option<String>,
}

impl InstructionStatusSearch5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.pmt_instr_sts { val.validate()? }
		if let Some(ref val) = self.pmt_instr_sts_dt_tm { val.validate()? }
		if let Some(ref val) = self.prtry_sts_rsn {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry_sts_rsn is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "prtry_sts_rsn exceeds the maximum length of 4".to_string()));
			}
			let pattern = Regex::new("[a-zA-Z0-9]{1,4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "prtry_sts_rsn does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// InstrumentAndSubClassIdentification2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InstrumentAndSubClassIdentification2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISIN") )]
	pub isin: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DerivSubClss", skip_serializing_if = "Option::is_none") )]
	pub deriv_sub_clss: Option<NonEquitySubClass1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmClssfctn", skip_serializing_if = "Option::is_none") )]
	pub fin_instrm_clssfctn: Option<NonEquityInstrumentReportingClassification1Code>,
}

impl InstrumentAndSubClassIdentification2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
		if !pattern.is_match(&self.isin) {
			return Err(ValidationError::new(1005, "isin does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.deriv_sub_clss { val.validate()? }
		if let Some(ref val) = self.fin_instrm_clssfctn { val.validate()? }
		Ok(())
	}
}


// InstrumentIdentification6Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InstrumentIdentification6Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISIN", skip_serializing_if = "Option::is_none") )]
	pub isin: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AltrntvInstrmId", skip_serializing_if = "Option::is_none") )]
	pub altrntv_instrm_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnqPdctIdr", skip_serializing_if = "Option::is_none") )]
	pub unq_pdct_idr: Option<UniqueProductIdentifier1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrId", skip_serializing_if = "Option::is_none") )]
	pub othr_id: Option<GenericIdentification184>,
}

impl InstrumentIdentification6Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.isin {
			let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "isin does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.altrntv_instrm_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "altrntv_instrm_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 52 {
				return Err(ValidationError::new(1002, "altrntv_instrm_id exceeds the maximum length of 52".to_string()));
			}
		}
		if let Some(ref val) = self.unq_pdct_idr { val.validate()? }
		if let Some(ref val) = self.othr_id { val.validate()? }
		Ok(())
	}
}


// InstrumentOrSubClassIdentification2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InstrumentOrSubClassIdentification2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISINAndSubClss", skip_serializing_if = "Option::is_none") )]
	pub isin_and_sub_clss: Option<InstrumentAndSubClassIdentification2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AsstClssAndSubClss", skip_serializing_if = "Option::is_none") )]
	pub asst_clss_and_sub_clss: Option<AssetClassAndSubClassIdentification2>,
}

impl InstrumentOrSubClassIdentification2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.isin_and_sub_clss { val.validate()? }
		if let Some(ref val) = self.asst_clss_and_sub_clss { val.validate()? }
		Ok(())
	}
}


// InstrumentSubStructureType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum InstrumentSubStructureType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ABSE") )]
	CodeABSE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AIRT") )]
	CodeAIRT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AUTT") )]
	CodeAUTT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CBOB") )]
	CodeCBOB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CDOB") )]
	CodeCDOB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CLNO") )]
	CodeCLNO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CLOB") )]
	CodeCLOB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CMBS") )]
	CodeCMBS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CSMR") )]
	CodeCSMR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CRCT") )]
	CodeCRCT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HELO") )]
	CodeHELO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LPNO") )]
	CodeLPNO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PFAB") )]
	CodePFAB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PYRT") )]
	CodePYRT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REPK") )]
	CodeREPK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RMBS") )]
	CodeRMBS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SCBO") )]
	CodeSCBO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "STRB") )]
	CodeSTRB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "STUT") )]
	CodeSTUT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WBSE") )]
	CodeWBSE,
}

impl InstrumentSubStructureType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// InstrumentSubStructureType2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InstrumentSubStructureType2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<InstrumentSubStructureType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl InstrumentSubStructureType2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// Insurance1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum Insurance1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "LIFE") )]
	CodeLIFE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PDIS") )]
	CodePDIS,
}

impl Insurance1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// InsuranceType2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InsuranceType2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<Insurance1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl InsuranceType2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// IntendedOrActual2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum IntendedOrActual2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ANTE") )]
	CodeANTE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "POST") )]
	CodePOST,
}

impl IntendedOrActual2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// InterestComputationMethod1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum InterestComputationMethod1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "A001") )]
	CodeA001,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A002") )]
	CodeA002,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A003") )]
	CodeA003,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A004") )]
	CodeA004,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A005") )]
	CodeA005,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A006") )]
	CodeA006,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A007") )]
	CodeA007,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A008") )]
	CodeA008,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A009") )]
	CodeA009,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A010") )]
	CodeA010,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A011") )]
	CodeA011,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A012") )]
	CodeA012,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A013") )]
	CodeA013,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A014") )]
	CodeA014,
}

impl InterestComputationMethod1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// InterestComputationMethod2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum InterestComputationMethod2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "A001") )]
	CodeA001,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A002") )]
	CodeA002,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A003") )]
	CodeA003,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A004") )]
	CodeA004,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A005") )]
	CodeA005,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A006") )]
	CodeA006,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A007") )]
	CodeA007,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A008") )]
	CodeA008,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A009") )]
	CodeA009,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A010") )]
	CodeA010,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A011") )]
	CodeA011,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A012") )]
	CodeA012,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A013") )]
	CodeA013,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A014") )]
	CodeA014,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NARR") )]
	CodeNARR,
}

impl InterestComputationMethod2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// InterestComputationMethod4Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum InterestComputationMethod4Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "A004") )]
	CodeA004,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A019") )]
	CodeA019,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A017") )]
	CodeA017,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A005") )]
	CodeA005,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A009") )]
	CodeA009,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A014") )]
	CodeA014,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A010") )]
	CodeA010,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A006") )]
	CodeA006,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A008") )]
	CodeA008,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A015") )]
	CodeA015,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A018") )]
	CodeA018,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A011") )]
	CodeA011,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A001") )]
	CodeA001,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A002") )]
	CodeA002,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A003") )]
	CodeA003,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A012") )]
	CodeA012,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A013") )]
	CodeA013,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A007") )]
	CodeA007,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A016") )]
	CodeA016,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NARR") )]
	CodeNARR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "A020") )]
	CodeA020,
}

impl InterestComputationMethod4Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// InterestComputationMethodFormat6Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InterestComputationMethodFormat6Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<InterestComputationMethod1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl InterestComputationMethodFormat6Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// InterestComputationMethodFormat7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InterestComputationMethodFormat7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd") )]
	pub cd: InterestComputationMethod4Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nrrtv", skip_serializing_if = "Option::is_none") )]
	pub nrrtv: Option<String>,
}

impl InterestComputationMethodFormat7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.cd.validate()?;
		if let Some(ref val) = self.nrrtv {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nrrtv is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 1000 {
				return Err(ValidationError::new(1002, "nrrtv exceeds the maximum length of 1000".to_string()));
			}
		}
		Ok(())
	}
}


// InterestPaymentDateRange1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InterestPaymentDateRange1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstSchdlId", skip_serializing_if = "Option::is_none") )]
	pub intrst_schdl_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XpctdDt", skip_serializing_if = "Option::is_none") )]
	pub xpctd_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DueDt", skip_serializing_if = "Option::is_none") )]
	pub due_dt: Option<String>,
}

impl InterestPaymentDateRange1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.intrst_schdl_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "intrst_schdl_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "intrst_schdl_id exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// InterestPaymentSchedule1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InterestPaymentSchedule1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstSchdlId", skip_serializing_if = "Option::is_none") )]
	pub intrst_schdl_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XpctdDt", skip_serializing_if = "Option::is_none") )]
	pub xpctd_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DueDt", skip_serializing_if = "Option::is_none") )]
	pub due_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
}

impl InterestPaymentSchedule1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.intrst_schdl_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "intrst_schdl_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "intrst_schdl_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.amt { val.validate()? }
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 1025 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 1025".to_string()));
			}
		}
		Ok(())
	}
}


// InterestRate27Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InterestRate27Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Fxd", skip_serializing_if = "Option::is_none") )]
	pub fxd: Option<FixedRate11>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Fltg", skip_serializing_if = "Option::is_none") )]
	pub fltg: Option<FloatingInterestRate22>,
}

impl InterestRate27Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.fxd { val.validate()? }
		if let Some(ref val) = self.fltg { val.validate()? }
		Ok(())
	}
}


// InterestRate2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InterestRate2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Fxd", skip_serializing_if = "Option::is_none") )]
	pub fxd: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Fltg", skip_serializing_if = "Option::is_none") )]
	pub fltg: Option<FloatingInterestRate4>,
}

impl InterestRate2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.fltg { val.validate()? }
		Ok(())
	}
}


// InterestRate33Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InterestRate33Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Fxd", skip_serializing_if = "Option::is_none") )]
	pub fxd: Option<FixedRate10>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Fltg", skip_serializing_if = "Option::is_none") )]
	pub fltg: Option<FloatingRate13>,
}

impl InterestRate33Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.fxd { val.validate()? }
		if let Some(ref val) = self.fltg { val.validate()? }
		Ok(())
	}
}


// InterestRate6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InterestRate6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: AmountAndDirection53,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstRate") )]
	pub intrst_rate: InterestRate27Choice,
}

impl InterestRate6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.amt.validate()?;
		self.intrst_rate.validate()?;
		Ok(())
	}
}


// InterestRate6Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InterestRate6Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Fxd", skip_serializing_if = "Option::is_none") )]
	pub fxd: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Fltg", skip_serializing_if = "Option::is_none") )]
	pub fltg: Option<FloatingInterestRate6>,
}

impl InterestRate6Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.fltg { val.validate()? }
		Ok(())
	}
}


// InterestRate8Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InterestRate8Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Fxd", skip_serializing_if = "Option::is_none") )]
	pub fxd: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Fltg", skip_serializing_if = "Option::is_none") )]
	pub fltg: Option<FloatingInterestRate8>,
}

impl InterestRate8Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.fltg { val.validate()? }
		Ok(())
	}
}


// InterestRateContractTerm1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InterestRateContractTerm1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Unit") )]
	pub unit: RateBasis1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val") )]
	pub val: f64,
}

impl InterestRateContractTerm1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.unit.validate()?;
		Ok(())
	}
}


// InterestRateContractTerm2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InterestRateContractTerm2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Unit") )]
	pub unit: RateBasis1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val") )]
	pub val: f64,
}

impl InterestRateContractTerm2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.unit.validate()?;
		Ok(())
	}
}


// InterestRateContractTerm4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InterestRateContractTerm4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Unit", skip_serializing_if = "Option::is_none") )]
	pub unit: Option<Frequency13Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val", skip_serializing_if = "Option::is_none") )]
	pub val: Option<f64>,
}

impl InterestRateContractTerm4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.unit { val.validate()? }
		Ok(())
	}
}


// InterestRateDerivative2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InterestRateDerivative2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SwpRltd", skip_serializing_if = "Option::is_none") )]
	pub swp_rltd: Option<SwapType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<UnderlyingInterestRateType3Code>,
}

impl InterestRateDerivative2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.swp_rltd { val.validate()? }
		if let Some(ref val) = self.othr { val.validate()? }
		Ok(())
	}
}


// InterestRateDerivative5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InterestRateDerivative5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "UndrlygTp") )]
	pub undrlyg_tp: InterestRateDerivative2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UndrlygBd", skip_serializing_if = "Option::is_none") )]
	pub undrlyg_bd: Option<BondDerivative2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SwptnNtnlCcy", skip_serializing_if = "Option::is_none") )]
	pub swptn_ntnl_ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UndrlygSwpMtrtyDt", skip_serializing_if = "Option::is_none") )]
	pub undrlyg_swp_mtrty_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InfltnIndx", skip_serializing_if = "Option::is_none") )]
	pub infltn_indx: Option<InflationIndex1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstRateRef") )]
	pub intrst_rate_ref: FloatingInterestRate8,
}

impl InterestRateDerivative5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.undrlyg_tp.validate()?;
		if let Some(ref val) = self.undrlyg_bd { val.validate()? }
		if let Some(ref val) = self.swptn_ntnl_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "swptn_ntnl_ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.infltn_indx { val.validate()? }
		self.intrst_rate_ref.validate()?;
		Ok(())
	}
}


// InterestRateFrequency3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InterestRateFrequency3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Term", skip_serializing_if = "Option::is_none") )]
	pub term: Option<InterestRateContractTerm4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl InterestRateFrequency3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.term { val.validate()? }
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 52 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 52".to_string()));
			}
		}
		Ok(())
	}
}


// InterestRateLegs14 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InterestRateLegs14 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrstLeg", skip_serializing_if = "Option::is_none") )]
	pub frst_leg: Option<InterestRate33Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ScndLeg", skip_serializing_if = "Option::is_none") )]
	pub scnd_leg: Option<InterestRate33Choice>,
}

impl InterestRateLegs14 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.frst_leg { val.validate()? }
		if let Some(ref val) = self.scnd_leg { val.validate()? }
		Ok(())
	}
}


// InterestRateType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum InterestRateType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "FIXE") )]
	CodeFIXE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VARI") )]
	CodeVARI,
}

impl InterestRateType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// InterestRecord2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InterestRecord2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveOrHistoricCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbtInd") )]
	pub cdt_dbt_ind: CreditDebitCode,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<InterestType1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rate", skip_serializing_if = "Option::is_none") )]
	pub rate: Option<Rate4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrToDt", skip_serializing_if = "Option::is_none") )]
	pub fr_to_dt: Option<DateTimePeriod1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tax", skip_serializing_if = "Option::is_none") )]
	pub tax: Option<TaxCharges2>,
}

impl InterestRecord2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.amt.validate()?;
		self.cdt_dbt_ind.validate()?;
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.rate { val.validate()? }
		if let Some(ref val) = self.fr_to_dt { val.validate()? }
		if let Some(ref val) = self.rsn {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rsn is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "rsn exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.tax { val.validate()? }
		Ok(())
	}
}


// InterestType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InterestType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<InterestType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl InterestType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// InterestType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum InterestType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "INDY") )]
	CodeINDY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OVRN") )]
	CodeOVRN,
}

impl InterestType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// InterestType3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum InterestType3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ZCPN") )]
	CodeZCPN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FIXD") )]
	CodeFIXD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FLRN") )]
	CodeFLRN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DUAL") )]
	CodeDUAL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INDE") )]
	CodeINDE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DSCO") )]
	CodeDSCO,
}

impl InterestType3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Intermediary46 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Intermediary46 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: PartyIdentification177Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LglNttyIdr", skip_serializing_if = "Option::is_none") )]
	pub lgl_ntty_idr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Acct", skip_serializing_if = "Option::is_none") )]
	pub acct: Option<Account32>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WvdTrlrComssnInd", skip_serializing_if = "Option::is_none") )]
	pub wvd_trlr_comssn_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Role", skip_serializing_if = "Option::is_none") )]
	pub role: Option<PartyRole2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmryComAdr", skip_serializing_if = "Option::is_none") )]
	pub pmry_com_adr: Option<Vec<CommunicationAddress6>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ScndryComAdr", skip_serializing_if = "Option::is_none") )]
	pub scndry_com_adr: Option<Vec<CommunicationAddress6>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NmAndAdr", skip_serializing_if = "Option::is_none") )]
	pub nm_and_adr: Option<NameAndAddress4>,
}

impl Intermediary46 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.id.validate()?;
		if let Some(ref val) = self.lgl_ntty_idr {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "lgl_ntty_idr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.acct { val.validate()? }
		if let Some(ref val) = self.role { val.validate()? }
		if let Some(ref vec) = self.pmry_com_adr { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.scndry_com_adr { for item in vec { item.validate()? } }
		if let Some(ref val) = self.nm_and_adr { val.validate()? }
		Ok(())
	}
}


// Intermediary47 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Intermediary47 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: PartyIdentification125Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LglNttyIdr", skip_serializing_if = "Option::is_none") )]
	pub lgl_ntty_idr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Acct", skip_serializing_if = "Option::is_none") )]
	pub acct: Option<Account32>,
}

impl Intermediary47 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.id.validate()?;
		if let Some(ref val) = self.lgl_ntty_idr {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "lgl_ntty_idr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.acct { val.validate()? }
		Ok(())
	}
}


// InternalPartyRole1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum InternalPartyRole1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "INTC") )]
	CodeINTC,
}

impl InternalPartyRole1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// InternalisationData1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InternalisationData1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Aggt") )]
	pub aggt: InternalisationData2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FaildRate") )]
	pub faild_rate: InternalisationDataRate1,
}

impl InternalisationData1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.aggt.validate()?;
		self.faild_rate.validate()?;
		Ok(())
	}
}


// InternalisationData2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InternalisationData2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sttld") )]
	pub sttld: InternalisationDataVolume1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Faild") )]
	pub faild: InternalisationDataVolume1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ttl") )]
	pub ttl: InternalisationDataVolume1,
}

impl InternalisationData2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.sttld.validate()?;
		self.faild.validate()?;
		self.ttl.validate()?;
		Ok(())
	}
}


// InternalisationDataRate1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InternalisationDataRate1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "VolPctg") )]
	pub vol_pctg: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val") )]
	pub val: f64,
}

impl InternalisationDataRate1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// InternalisationDataVolume1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InternalisationDataVolume1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Vol") )]
	pub vol: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val") )]
	pub val: f64,
}

impl InternalisationDataVolume1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.vol < 0.000000 {
			return Err(ValidationError::new(1003, "vol is less than the minimum value of 0.000000".to_string()));
		}
		if self.val < 0.000000 {
			return Err(ValidationError::new(1003, "val is less than the minimum value of 0.000000".to_string()));
		}
		Ok(())
	}
}


// InteroperabilityCCP1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InteroperabilityCCP1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: GenericIdentification168,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlInitlMrgn") )]
	pub ttl_initl_mrgn: Vec<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrdsClrd", skip_serializing_if = "Option::is_none") )]
	pub trds_clrd: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GrssNtnlAmt") )]
	pub grss_ntnl_amt: Vec<ActiveCurrencyAnd24Amount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AsstHldg") )]
	pub asst_hldg: Vec<AssetHolding3>,
}

impl InteroperabilityCCP1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.id.validate()?;
		for item in &self.ttl_initl_mrgn { item.validate()? }
		if let Some(ref val) = self.trds_clrd {
			if *val < 0.000000 {
				return Err(ValidationError::new(1003, "trds_clrd is less than the minimum value of 0.000000".to_string()));
			}
		}
		for item in &self.grss_ntnl_amt { item.validate()? }
		for item in &self.asst_hldg { item.validate()? }
		Ok(())
	}
}


// IntraBalance5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IntraBalance5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmAmt") )]
	pub sttlm_amt: Amount2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmDt") )]
	pub sttlm_dt: DateAndDateTime2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BalFr") )]
	pub bal_fr: CashSubBalanceTypeAndQuantityBreakdown3,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BalTo") )]
	pub bal_to: CashSubBalanceTypeAndQuantityBreakdown3,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshSubBalId", skip_serializing_if = "Option::is_none") )]
	pub csh_sub_bal_id: Option<GenericIdentification37>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prty", skip_serializing_if = "Option::is_none") )]
	pub prty: Option<PriorityNumeric4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrPrcgAddtlDtls", skip_serializing_if = "Option::is_none") )]
	pub instr_prcg_addtl_dtls: Option<String>,
}

impl IntraBalance5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.sttlm_amt.validate()?;
		self.sttlm_dt.validate()?;
		self.bal_fr.validate()?;
		self.bal_to.validate()?;
		if let Some(ref val) = self.csh_sub_bal_id { val.validate()? }
		if let Some(ref val) = self.prty { val.validate()? }
		if let Some(ref val) = self.instr_prcg_addtl_dtls {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "instr_prcg_addtl_dtls is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "instr_prcg_addtl_dtls exceeds the maximum length of 350".to_string()));
			}
		}
		Ok(())
	}
}


// IntraBalance6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IntraBalance6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttldAmt", skip_serializing_if = "Option::is_none") )]
	pub sttld_amt: Option<Amount2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrevslySttldAmt", skip_serializing_if = "Option::is_none") )]
	pub prevsly_sttld_amt: Option<Amount2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RmngSttlmAmt", skip_serializing_if = "Option::is_none") )]
	pub rmng_sttlm_amt: Option<Amount2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmDt") )]
	pub sttlm_dt: DateAndDateTime2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BalFr") )]
	pub bal_fr: CashSubBalanceTypeAndQuantityBreakdown3,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BalTo") )]
	pub bal_to: CashSubBalanceTypeAndQuantityBreakdown3,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshSubBalId", skip_serializing_if = "Option::is_none") )]
	pub csh_sub_bal_id: Option<GenericIdentification37>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrPrcgAddtlDtls", skip_serializing_if = "Option::is_none") )]
	pub instr_prcg_addtl_dtls: Option<String>,
}

impl IntraBalance6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.sttld_amt { val.validate()? }
		if let Some(ref val) = self.prevsly_sttld_amt { val.validate()? }
		if let Some(ref val) = self.rmng_sttlm_amt { val.validate()? }
		self.sttlm_dt.validate()?;
		self.bal_fr.validate()?;
		self.bal_to.validate()?;
		if let Some(ref val) = self.csh_sub_bal_id { val.validate()? }
		if let Some(ref val) = self.instr_prcg_addtl_dtls {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "instr_prcg_addtl_dtls is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "instr_prcg_addtl_dtls exceeds the maximum length of 350".to_string()));
			}
		}
		Ok(())
	}
}


// IntraBalanceCancellation7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IntraBalanceCancellation7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshAcct", skip_serializing_if = "Option::is_none") )]
	pub csh_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshAcctOwnr", skip_serializing_if = "Option::is_none") )]
	pub csh_acct_ownr: Option<SystemPartyIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshAcctSvcr", skip_serializing_if = "Option::is_none") )]
	pub csh_acct_svcr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrcgSts", skip_serializing_if = "Option::is_none") )]
	pub prcg_sts: Option<ProcessingStatus69Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cxl") )]
	pub cxl: Vec<IntraBalanceCancellation8>,
}

impl IntraBalanceCancellation7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.csh_acct { val.validate()? }
		if let Some(ref val) = self.csh_acct_ownr { val.validate()? }
		if let Some(ref val) = self.csh_acct_svcr { val.validate()? }
		if let Some(ref val) = self.prcg_sts { val.validate()? }
		for item in &self.cxl { item.validate()? }
		Ok(())
	}
}


// IntraBalanceCancellation8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IntraBalanceCancellation8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshAcct", skip_serializing_if = "Option::is_none") )]
	pub csh_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshAcctOwnr", skip_serializing_if = "Option::is_none") )]
	pub csh_acct_ownr: Option<SystemPartyIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshAcctSvcr", skip_serializing_if = "Option::is_none") )]
	pub csh_acct_svcr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrcgSts", skip_serializing_if = "Option::is_none") )]
	pub prcg_sts: Option<ProcessingStatus69Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqRef") )]
	pub req_ref: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsDt", skip_serializing_if = "Option::is_none") )]
	pub sts_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxId", skip_serializing_if = "Option::is_none") )]
	pub tx_id: Option<References14>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UndrlygIntraBal", skip_serializing_if = "Option::is_none") )]
	pub undrlyg_intra_bal: Option<IntraBalance5>,
}

impl IntraBalanceCancellation8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.csh_acct { val.validate()? }
		if let Some(ref val) = self.csh_acct_ownr { val.validate()? }
		if let Some(ref val) = self.csh_acct_svcr { val.validate()? }
		if let Some(ref val) = self.prcg_sts { val.validate()? }
		if self.req_ref.chars().count() < 1 {
			return Err(ValidationError::new(1001, "req_ref is shorter than the minimum length of 1".to_string()));
		}
		if self.req_ref.chars().count() > 35 {
			return Err(ValidationError::new(1002, "req_ref exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.tx_id { val.validate()? }
		if let Some(ref val) = self.undrlyg_intra_bal { val.validate()? }
		Ok(())
	}
}


// IntraBalanceModification7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IntraBalanceModification7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshAcct", skip_serializing_if = "Option::is_none") )]
	pub csh_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshAcctOwnr", skip_serializing_if = "Option::is_none") )]
	pub csh_acct_ownr: Option<SystemPartyIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshAcctSvcr", skip_serializing_if = "Option::is_none") )]
	pub csh_acct_svcr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrcgSts", skip_serializing_if = "Option::is_none") )]
	pub prcg_sts: Option<ProcessingStatus71Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mod") )]
	pub mod_attr: Vec<IntraBalanceModification8>,
}

impl IntraBalanceModification7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.csh_acct { val.validate()? }
		if let Some(ref val) = self.csh_acct_ownr { val.validate()? }
		if let Some(ref val) = self.csh_acct_svcr { val.validate()? }
		if let Some(ref val) = self.prcg_sts { val.validate()? }
		for item in &self.mod_attr { item.validate()? }
		Ok(())
	}
}


// IntraBalanceModification8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IntraBalanceModification8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshAcct", skip_serializing_if = "Option::is_none") )]
	pub csh_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshAcctOwnr", skip_serializing_if = "Option::is_none") )]
	pub csh_acct_ownr: Option<SystemPartyIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshAcctSvcr", skip_serializing_if = "Option::is_none") )]
	pub csh_acct_svcr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrcgSts", skip_serializing_if = "Option::is_none") )]
	pub prcg_sts: Option<ProcessingStatus71Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqRef") )]
	pub req_ref: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsDt", skip_serializing_if = "Option::is_none") )]
	pub sts_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqDtls", skip_serializing_if = "Option::is_none") )]
	pub req_dtls: Option<RequestDetails22>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UndrlygIntraBal", skip_serializing_if = "Option::is_none") )]
	pub undrlyg_intra_bal: Option<IntraBalance5>,
}

impl IntraBalanceModification8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.csh_acct { val.validate()? }
		if let Some(ref val) = self.csh_acct_ownr { val.validate()? }
		if let Some(ref val) = self.csh_acct_svcr { val.validate()? }
		if let Some(ref val) = self.prcg_sts { val.validate()? }
		if self.req_ref.chars().count() < 1 {
			return Err(ValidationError::new(1001, "req_ref is shorter than the minimum length of 1".to_string()));
		}
		if self.req_ref.chars().count() > 35 {
			return Err(ValidationError::new(1002, "req_ref exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.req_dtls { val.validate()? }
		if let Some(ref val) = self.undrlyg_intra_bal { val.validate()? }
		Ok(())
	}
}


// IntraBalanceMovement6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IntraBalanceMovement6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BalFr") )]
	pub bal_fr: CashSubBalanceTypeAndQuantityBreakdown3,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BalTo") )]
	pub bal_to: CashSubBalanceTypeAndQuantityBreakdown3,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmAmt") )]
	pub sttlm_amt: Amount2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttldAmt", skip_serializing_if = "Option::is_none") )]
	pub sttld_amt: Option<Amount2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrevslySttldAmt", skip_serializing_if = "Option::is_none") )]
	pub prevsly_sttld_amt: Option<Amount2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RmngSttlmAmt", skip_serializing_if = "Option::is_none") )]
	pub rmng_sttlm_amt: Option<Amount2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntnddSttlmDt") )]
	pub intndd_sttlm_dt: DateAndDateTime2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FctvSttlmDt", skip_serializing_if = "Option::is_none") )]
	pub fctv_sttlm_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsDt", skip_serializing_if = "Option::is_none") )]
	pub sts_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshSubBalId", skip_serializing_if = "Option::is_none") )]
	pub csh_sub_bal_id: Option<GenericIdentification37>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Lnkgs", skip_serializing_if = "Option::is_none") )]
	pub lnkgs: Option<Vec<Linkages57>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prty", skip_serializing_if = "Option::is_none") )]
	pub prty: Option<PriorityNumeric4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgOrgtr", skip_serializing_if = "Option::is_none") )]
	pub msg_orgtr: Option<SystemPartyIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm") )]
	pub cre_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrPrcgAddtlDtls", skip_serializing_if = "Option::is_none") )]
	pub instr_prcg_addtl_dtls: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl IntraBalanceMovement6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.bal_fr.validate()?;
		self.bal_to.validate()?;
		self.sttlm_amt.validate()?;
		if let Some(ref val) = self.sttld_amt { val.validate()? }
		if let Some(ref val) = self.prevsly_sttld_amt { val.validate()? }
		if let Some(ref val) = self.rmng_sttlm_amt { val.validate()? }
		self.intndd_sttlm_dt.validate()?;
		if let Some(ref val) = self.fctv_sttlm_dt { val.validate()? }
		if let Some(ref val) = self.csh_sub_bal_id { val.validate()? }
		if let Some(ref vec) = self.lnkgs { for item in vec { item.validate()? } }
		if let Some(ref val) = self.prty { val.validate()? }
		if let Some(ref val) = self.msg_orgtr { val.validate()? }
		if let Some(ref val) = self.instr_prcg_addtl_dtls {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "instr_prcg_addtl_dtls is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "instr_prcg_addtl_dtls exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// IntraBalanceMovement7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IntraBalanceMovement7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshAcct", skip_serializing_if = "Option::is_none") )]
	pub csh_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshAcctOwnr", skip_serializing_if = "Option::is_none") )]
	pub csh_acct_ownr: Option<SystemPartyIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshAcctSvcr", skip_serializing_if = "Option::is_none") )]
	pub csh_acct_svcr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsAndRsn", skip_serializing_if = "Option::is_none") )]
	pub sts_and_rsn: Option<IntraBalanceStatusAndReason2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctOwnrTxId") )]
	pub acct_ownr_tx_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcrTxId", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktInfrstrctrTxId", skip_serializing_if = "Option::is_none") )]
	pub mkt_infrstrctr_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrcrTxId", skip_serializing_if = "Option::is_none") )]
	pub prcr_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PoolId", skip_serializing_if = "Option::is_none") )]
	pub pool_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CorpActnEvtId", skip_serializing_if = "Option::is_none") )]
	pub corp_actn_evt_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MvmntDtls", skip_serializing_if = "Option::is_none") )]
	pub mvmnt_dtls: Option<IntraBalanceMovement6>,
}

impl IntraBalanceMovement7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.csh_acct { val.validate()? }
		if let Some(ref val) = self.csh_acct_ownr { val.validate()? }
		if let Some(ref val) = self.csh_acct_svcr { val.validate()? }
		if let Some(ref val) = self.sts_and_rsn { val.validate()? }
		if self.acct_ownr_tx_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "acct_ownr_tx_id is shorter than the minimum length of 1".to_string()));
		}
		if self.acct_ownr_tx_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "acct_ownr_tx_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.acct_svcr_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_svcr_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acct_svcr_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.mkt_infrstrctr_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mkt_infrstrctr_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "mkt_infrstrctr_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.prcr_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prcr_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prcr_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.pool_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pool_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "pool_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.corp_actn_evt_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "corp_actn_evt_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "corp_actn_evt_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.mvmnt_dtls { val.validate()? }
		Ok(())
	}
}


// IntraBalanceMovements4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IntraBalanceMovements4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshAcct", skip_serializing_if = "Option::is_none") )]
	pub csh_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshAcctOwnr", skip_serializing_if = "Option::is_none") )]
	pub csh_acct_ownr: Option<SystemPartyIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshAcctSvcr", skip_serializing_if = "Option::is_none") )]
	pub csh_acct_svcr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsAndRsn", skip_serializing_if = "Option::is_none") )]
	pub sts_and_rsn: Option<IntraBalanceStatusAndReason2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mvmnt") )]
	pub mvmnt: Vec<IntraBalanceMovement7>,
}

impl IntraBalanceMovements4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.csh_acct { val.validate()? }
		if let Some(ref val) = self.csh_acct_ownr { val.validate()? }
		if let Some(ref val) = self.csh_acct_svcr { val.validate()? }
		if let Some(ref val) = self.sts_and_rsn { val.validate()? }
		for item in &self.mvmnt { item.validate()? }
		Ok(())
	}
}


// IntraBalanceOrOperationalError10Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IntraBalanceOrOperationalError10Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cxls", skip_serializing_if = "Option::is_none") )]
	pub cxls: Option<Vec<IntraBalanceCancellation7>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OprlErr", skip_serializing_if = "Option::is_none") )]
	pub oprl_err: Option<Vec<ErrorHandling5>>,
}

impl IntraBalanceOrOperationalError10Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.cxls { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.oprl_err { for item in vec { item.validate()? } }
		Ok(())
	}
}


// IntraBalanceOrOperationalError11Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IntraBalanceOrOperationalError11Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mvmnts", skip_serializing_if = "Option::is_none") )]
	pub mvmnts: Option<Vec<IntraBalanceMovements4>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OprlErr", skip_serializing_if = "Option::is_none") )]
	pub oprl_err: Option<Vec<ErrorHandling5>>,
}

impl IntraBalanceOrOperationalError11Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.mvmnts { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.oprl_err { for item in vec { item.validate()? } }
		Ok(())
	}
}


// IntraBalanceOrOperationalError12Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IntraBalanceOrOperationalError12Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mods", skip_serializing_if = "Option::is_none") )]
	pub mods: Option<Vec<IntraBalanceModification7>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OprlErr", skip_serializing_if = "Option::is_none") )]
	pub oprl_err: Option<Vec<ErrorHandling5>>,
}

impl IntraBalanceOrOperationalError12Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.mods { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.oprl_err { for item in vec { item.validate()? } }
		Ok(())
	}
}


// IntraBalancePending5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IntraBalancePending5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsAndRsn", skip_serializing_if = "Option::is_none") )]
	pub sts_and_rsn: Option<PendingStatusAndReason2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mvmnt") )]
	pub mvmnt: Vec<IntraBalancePending6>,
}

impl IntraBalancePending5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.sts_and_rsn { val.validate()? }
		for item in &self.mvmnt { item.validate()? }
		Ok(())
	}
}


// IntraBalancePending6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IntraBalancePending6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsAndRsn", skip_serializing_if = "Option::is_none") )]
	pub sts_and_rsn: Option<PendingStatusAndReason2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctOwnrTxId") )]
	pub acct_ownr_tx_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcrTxId", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktInfrstrctrTxId", skip_serializing_if = "Option::is_none") )]
	pub mkt_infrstrctr_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrcrTxId", skip_serializing_if = "Option::is_none") )]
	pub prcr_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PoolId", skip_serializing_if = "Option::is_none") )]
	pub pool_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CorpActnEvtId", skip_serializing_if = "Option::is_none") )]
	pub corp_actn_evt_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BalFr") )]
	pub bal_fr: CashSubBalanceTypeAndQuantityBreakdown3,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BalTo") )]
	pub bal_to: CashSubBalanceTypeAndQuantityBreakdown3,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmAmt") )]
	pub sttlm_amt: Amount2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntnddSttlmDt") )]
	pub intndd_sttlm_dt: DateAndDateTime2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsDt", skip_serializing_if = "Option::is_none") )]
	pub sts_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshSubBalId", skip_serializing_if = "Option::is_none") )]
	pub csh_sub_bal_id: Option<GenericIdentification37>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Lnkgs", skip_serializing_if = "Option::is_none") )]
	pub lnkgs: Option<Vec<Linkages57>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prty", skip_serializing_if = "Option::is_none") )]
	pub prty: Option<PriorityNumeric4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgOrgtr", skip_serializing_if = "Option::is_none") )]
	pub msg_orgtr: Option<SystemPartyIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm") )]
	pub cre_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrPrcgAddtlDtls", skip_serializing_if = "Option::is_none") )]
	pub instr_prcg_addtl_dtls: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl IntraBalancePending6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.sts_and_rsn { val.validate()? }
		if self.acct_ownr_tx_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "acct_ownr_tx_id is shorter than the minimum length of 1".to_string()));
		}
		if self.acct_ownr_tx_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "acct_ownr_tx_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.acct_svcr_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_svcr_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acct_svcr_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.mkt_infrstrctr_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mkt_infrstrctr_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "mkt_infrstrctr_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.prcr_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prcr_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prcr_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.pool_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pool_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "pool_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.corp_actn_evt_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "corp_actn_evt_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "corp_actn_evt_id exceeds the maximum length of 35".to_string()));
			}
		}
		self.bal_fr.validate()?;
		self.bal_to.validate()?;
		self.sttlm_amt.validate()?;
		self.intndd_sttlm_dt.validate()?;
		if let Some(ref val) = self.csh_sub_bal_id { val.validate()? }
		if let Some(ref vec) = self.lnkgs { for item in vec { item.validate()? } }
		if let Some(ref val) = self.prty { val.validate()? }
		if let Some(ref val) = self.msg_orgtr { val.validate()? }
		if let Some(ref val) = self.instr_prcg_addtl_dtls {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "instr_prcg_addtl_dtls is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "instr_prcg_addtl_dtls exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// IntraBalancePosting5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IntraBalancePosting5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BalFr") )]
	pub bal_fr: CashSubBalanceTypeAndQuantityBreakdown3,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mvmnt") )]
	pub mvmnt: Vec<IntraBalancePosting6>,
}

impl IntraBalancePosting5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.bal_fr.validate()?;
		for item in &self.mvmnt { item.validate()? }
		Ok(())
	}
}


// IntraBalancePosting6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IntraBalancePosting6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctOwnrTxId") )]
	pub acct_ownr_tx_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcrTxId", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktInfrstrctrTxId", skip_serializing_if = "Option::is_none") )]
	pub mkt_infrstrctr_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrcrTxId", skip_serializing_if = "Option::is_none") )]
	pub prcr_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PoolId", skip_serializing_if = "Option::is_none") )]
	pub pool_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CorpActnEvtId", skip_serializing_if = "Option::is_none") )]
	pub corp_actn_evt_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BalTo") )]
	pub bal_to: CashSubBalanceTypeAndQuantityBreakdown3,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttldAmt") )]
	pub sttld_amt: Amount2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrevslySttldAmt", skip_serializing_if = "Option::is_none") )]
	pub prevsly_sttld_amt: Option<Amount2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RmngSttlmAmt", skip_serializing_if = "Option::is_none") )]
	pub rmng_sttlm_amt: Option<Amount2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FctvSttlmDt") )]
	pub fctv_sttlm_dt: DateAndDateTime2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsDt", skip_serializing_if = "Option::is_none") )]
	pub sts_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshSubBalId", skip_serializing_if = "Option::is_none") )]
	pub csh_sub_bal_id: Option<GenericIdentification37>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Lnkgs", skip_serializing_if = "Option::is_none") )]
	pub lnkgs: Option<Vec<Linkages57>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prty", skip_serializing_if = "Option::is_none") )]
	pub prty: Option<PriorityNumeric4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgOrgtr", skip_serializing_if = "Option::is_none") )]
	pub msg_orgtr: Option<SystemPartyIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm") )]
	pub cre_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrPrcgAddtlDtls", skip_serializing_if = "Option::is_none") )]
	pub instr_prcg_addtl_dtls: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl IntraBalancePosting6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.acct_ownr_tx_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "acct_ownr_tx_id is shorter than the minimum length of 1".to_string()));
		}
		if self.acct_ownr_tx_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "acct_ownr_tx_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.acct_svcr_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_svcr_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acct_svcr_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.mkt_infrstrctr_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mkt_infrstrctr_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "mkt_infrstrctr_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.prcr_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prcr_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prcr_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.pool_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pool_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "pool_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.corp_actn_evt_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "corp_actn_evt_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "corp_actn_evt_id exceeds the maximum length of 35".to_string()));
			}
		}
		self.bal_to.validate()?;
		self.sttld_amt.validate()?;
		if let Some(ref val) = self.prevsly_sttld_amt { val.validate()? }
		if let Some(ref val) = self.rmng_sttlm_amt { val.validate()? }
		self.fctv_sttlm_dt.validate()?;
		if let Some(ref val) = self.csh_sub_bal_id { val.validate()? }
		if let Some(ref vec) = self.lnkgs { for item in vec { item.validate()? } }
		if let Some(ref val) = self.prty { val.validate()? }
		if let Some(ref val) = self.msg_orgtr { val.validate()? }
		if let Some(ref val) = self.instr_prcg_addtl_dtls {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "instr_prcg_addtl_dtls is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "instr_prcg_addtl_dtls exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// IntraBalanceQueryCriteria10 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IntraBalanceQueryCriteria10 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CxlReqId", skip_serializing_if = "Option::is_none") )]
	pub cxl_req_id: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrcgSts", skip_serializing_if = "Option::is_none") )]
	pub prcg_sts: Option<Vec<CancellationProcessingStatus9Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshAcct", skip_serializing_if = "Option::is_none") )]
	pub csh_acct: Option<Vec<AccountIdentificationSearchCriteria2Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshAcctOwnr", skip_serializing_if = "Option::is_none") )]
	pub csh_acct_ownr: Option<Vec<SystemPartyIdentification8>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshAcctSvcr", skip_serializing_if = "Option::is_none") )]
	pub csh_acct_svcr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgOrgtr", skip_serializing_if = "Option::is_none") )]
	pub msg_orgtr: Option<Vec<SystemPartyIdentification8>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm", skip_serializing_if = "Option::is_none") )]
	pub cre_dt_tm: Option<DateAndDateTimeSearch5Choice>,
}

impl IntraBalanceQueryCriteria10 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.cxl_req_id {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "cxl_req_id is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 35 {
					return Err(ValidationError::new(1002, "cxl_req_id exceeds the maximum length of 35".to_string()));
				}
			}
		}
		if let Some(ref vec) = self.prcg_sts { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.csh_acct { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.csh_acct_ownr { for item in vec { item.validate()? } }
		if let Some(ref val) = self.csh_acct_svcr { val.validate()? }
		if let Some(ref vec) = self.msg_orgtr { for item in vec { item.validate()? } }
		if let Some(ref val) = self.cre_dt_tm { val.validate()? }
		Ok(())
	}
}


// IntraBalanceQueryCriteria11 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IntraBalanceQueryCriteria11 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Refs", skip_serializing_if = "Option::is_none") )]
	pub refs: Option<Vec<References36Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts", skip_serializing_if = "Option::is_none") )]
	pub sts: Option<IntraBalanceQueryStatus3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshAcct", skip_serializing_if = "Option::is_none") )]
	pub csh_acct: Option<Vec<AccountIdentificationSearchCriteria2Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshAcctOwnr", skip_serializing_if = "Option::is_none") )]
	pub csh_acct_ownr: Option<Vec<SystemPartyIdentification8>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshAcctSvcr", skip_serializing_if = "Option::is_none") )]
	pub csh_acct_svcr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BalTp", skip_serializing_if = "Option::is_none") )]
	pub bal_tp: Option<Vec<IntraBalanceType3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshSubBalId", skip_serializing_if = "Option::is_none") )]
	pub csh_sub_bal_id: Option<Vec<GenericIdentification37>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmAmt", skip_serializing_if = "Option::is_none") )]
	pub sttlm_amt: Option<ImpliedCurrencyAmountRange1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttldAmt", skip_serializing_if = "Option::is_none") )]
	pub sttld_amt: Option<ImpliedCurrencyAmountRange1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmCcy", skip_serializing_if = "Option::is_none") )]
	pub sttlm_ccy: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntnddSttlmDt", skip_serializing_if = "Option::is_none") )]
	pub intndd_sttlm_dt: Option<DateAndDateTimeSearch5Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FctvSttlmDt", skip_serializing_if = "Option::is_none") )]
	pub fctv_sttlm_dt: Option<DateAndDateTimeSearch5Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prty", skip_serializing_if = "Option::is_none") )]
	pub prty: Option<Vec<PriorityNumeric4Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgOrgtr", skip_serializing_if = "Option::is_none") )]
	pub msg_orgtr: Option<Vec<SystemPartyIdentification8>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm", skip_serializing_if = "Option::is_none") )]
	pub cre_dt_tm: Option<DateAndDateTimeSearch5Choice>,
}

impl IntraBalanceQueryCriteria11 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.refs { for item in vec { item.validate()? } }
		if let Some(ref val) = self.sts { val.validate()? }
		if let Some(ref vec) = self.csh_acct { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.csh_acct_ownr { for item in vec { item.validate()? } }
		if let Some(ref val) = self.csh_acct_svcr { val.validate()? }
		if let Some(ref vec) = self.bal_tp { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.csh_sub_bal_id { for item in vec { item.validate()? } }
		if let Some(ref val) = self.sttlm_amt { val.validate()? }
		if let Some(ref val) = self.sttld_amt { val.validate()? }
		if let Some(ref vec) = self.sttlm_ccy {
			for item in vec {
				let pattern = Regex::new("[A-Z]{3,3}").unwrap();
				if !pattern.is_match(&item) {
					return Err(ValidationError::new(1005, "sttlm_ccy does not match the required pattern".to_string()));
				}
			}
		}
		if let Some(ref val) = self.intndd_sttlm_dt { val.validate()? }
		if let Some(ref val) = self.fctv_sttlm_dt { val.validate()? }
		if let Some(ref vec) = self.prty { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.msg_orgtr { for item in vec { item.validate()? } }
		if let Some(ref val) = self.cre_dt_tm { val.validate()? }
		Ok(())
	}
}


// IntraBalanceQueryCriteria12 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IntraBalanceQueryCriteria12 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModReqId", skip_serializing_if = "Option::is_none") )]
	pub mod_req_id: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrcgSts", skip_serializing_if = "Option::is_none") )]
	pub prcg_sts: Option<Vec<ModificationProcessingStatus9Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshAcct", skip_serializing_if = "Option::is_none") )]
	pub csh_acct: Option<Vec<AccountIdentificationSearchCriteria2Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshAcctOwnr", skip_serializing_if = "Option::is_none") )]
	pub csh_acct_ownr: Option<Vec<SystemPartyIdentification8>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshAcctSvcr", skip_serializing_if = "Option::is_none") )]
	pub csh_acct_svcr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgOrgtr", skip_serializing_if = "Option::is_none") )]
	pub msg_orgtr: Option<Vec<SystemPartyIdentification8>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm", skip_serializing_if = "Option::is_none") )]
	pub cre_dt_tm: Option<DateAndDateTimeSearch5Choice>,
}

impl IntraBalanceQueryCriteria12 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.mod_req_id {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "mod_req_id is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 35 {
					return Err(ValidationError::new(1002, "mod_req_id exceeds the maximum length of 35".to_string()));
				}
			}
		}
		if let Some(ref vec) = self.prcg_sts { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.csh_acct { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.csh_acct_ownr { for item in vec { item.validate()? } }
		if let Some(ref val) = self.csh_acct_svcr { val.validate()? }
		if let Some(ref vec) = self.msg_orgtr { for item in vec { item.validate()? } }
		if let Some(ref val) = self.cre_dt_tm { val.validate()? }
		Ok(())
	}
}


// IntraBalanceQueryDefinition10 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IntraBalanceQueryDefinition10 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "QryTp") )]
	pub qry_tp: MovementResponseType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SchCrit") )]
	pub sch_crit: IntraBalanceQueryCriteria10,
}

impl IntraBalanceQueryDefinition10 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.qry_tp.validate()?;
		self.sch_crit.validate()?;
		Ok(())
	}
}


// IntraBalanceQueryDefinition11 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IntraBalanceQueryDefinition11 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "QryTp") )]
	pub qry_tp: MovementResponseType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SchCrit") )]
	pub sch_crit: IntraBalanceQueryCriteria11,
}

impl IntraBalanceQueryDefinition11 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.qry_tp.validate()?;
		self.sch_crit.validate()?;
		Ok(())
	}
}


// IntraBalanceQueryDefinition12 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IntraBalanceQueryDefinition12 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "QryTp") )]
	pub qry_tp: MovementResponseType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SchCrit") )]
	pub sch_crit: IntraBalanceQueryCriteria12,
}

impl IntraBalanceQueryDefinition12 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.qry_tp.validate()?;
		self.sch_crit.validate()?;
		Ok(())
	}
}


// IntraBalanceQueryStatus3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IntraBalanceQueryStatus3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: IntraBalanceStatusType2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtPrd", skip_serializing_if = "Option::is_none") )]
	pub dt_prd: Option<DateAndDateTimeSearch5Choice>,
}

impl IntraBalanceQueryStatus3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tp.validate()?;
		if let Some(ref val) = self.dt_prd { val.validate()? }
		Ok(())
	}
}


// IntraBalanceReport5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IntraBalanceReport5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptNb", skip_serializing_if = "Option::is_none") )]
	pub rpt_nb: Option<Number3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QryRef", skip_serializing_if = "Option::is_none") )]
	pub qry_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptId", skip_serializing_if = "Option::is_none") )]
	pub rpt_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptDtTm", skip_serializing_if = "Option::is_none") )]
	pub rpt_dt_tm: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptPrd", skip_serializing_if = "Option::is_none") )]
	pub rpt_prd: Option<Period7Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QryTp", skip_serializing_if = "Option::is_none") )]
	pub qry_tp: Option<MovementResponseType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Frqcy", skip_serializing_if = "Option::is_none") )]
	pub frqcy: Option<Frequency22Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UpdTp") )]
	pub upd_tp: UpdateType15Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ActvtyInd") )]
	pub actvty_ind: bool,
}

impl IntraBalanceReport5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rpt_nb { val.validate()? }
		if let Some(ref val) = self.qry_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "qry_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "qry_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.rpt_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rpt_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "rpt_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.rpt_dt_tm { val.validate()? }
		if let Some(ref val) = self.rpt_prd { val.validate()? }
		if let Some(ref val) = self.qry_tp { val.validate()? }
		if let Some(ref val) = self.frqcy { val.validate()? }
		self.upd_tp.validate()?;
		Ok(())
	}
}


// IntraBalanceReport6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IntraBalanceReport6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptNb", skip_serializing_if = "Option::is_none") )]
	pub rpt_nb: Option<Number3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QryRef", skip_serializing_if = "Option::is_none") )]
	pub qry_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptId", skip_serializing_if = "Option::is_none") )]
	pub rpt_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptDtTm", skip_serializing_if = "Option::is_none") )]
	pub rpt_dt_tm: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptPrd", skip_serializing_if = "Option::is_none") )]
	pub rpt_prd: Option<Period7Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Frqcy", skip_serializing_if = "Option::is_none") )]
	pub frqcy: Option<Frequency22Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UpdTp") )]
	pub upd_tp: UpdateType15Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ActvtyInd") )]
	pub actvty_ind: bool,
}

impl IntraBalanceReport6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rpt_nb { val.validate()? }
		if let Some(ref val) = self.qry_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "qry_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "qry_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.rpt_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rpt_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "rpt_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.rpt_dt_tm { val.validate()? }
		if let Some(ref val) = self.rpt_prd { val.validate()? }
		if let Some(ref val) = self.frqcy { val.validate()? }
		self.upd_tp.validate()?;
		Ok(())
	}
}


// IntraBalanceStatusAndReason2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IntraBalanceStatusAndReason2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrcgSts", skip_serializing_if = "Option::is_none") )]
	pub prcg_sts: Option<Vec<ProcessingStatus67Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmSts", skip_serializing_if = "Option::is_none") )]
	pub sttlm_sts: Option<Vec<SettlementStatus16Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sttld", skip_serializing_if = "Option::is_none") )]
	pub sttld: Option<ProprietaryReason4>,
}

impl IntraBalanceStatusAndReason2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.prcg_sts { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.sttlm_sts { for item in vec { item.validate()? } }
		if let Some(ref val) = self.sttld { val.validate()? }
		Ok(())
	}
}


// IntraBalanceStatusType2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IntraBalanceStatusType2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrcgSts", skip_serializing_if = "Option::is_none") )]
	pub prcg_sts: Option<Vec<ProcessingStatus68Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmSts", skip_serializing_if = "Option::is_none") )]
	pub sttlm_sts: Option<Vec<SettlementStatus26Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sttld", skip_serializing_if = "Option::is_none") )]
	pub sttld: Option<ProprietaryReason4>,
}

impl IntraBalanceStatusType2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.prcg_sts { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.sttlm_sts { for item in vec { item.validate()? } }
		if let Some(ref val) = self.sttld { val.validate()? }
		Ok(())
	}
}


// IntraBalanceType3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IntraBalanceType3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BalFr", skip_serializing_if = "Option::is_none") )]
	pub bal_fr: Option<CashSubBalanceTypeAndQuantityBreakdown3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BalTo", skip_serializing_if = "Option::is_none") )]
	pub bal_to: Option<CashSubBalanceTypeAndQuantityBreakdown3>,
}

impl IntraBalanceType3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.bal_fr { val.validate()? }
		if let Some(ref val) = self.bal_to { val.validate()? }
		Ok(())
	}
}


// IntraDayMarginCall1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IntraDayMarginCall1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MrgnAcctId") )]
	pub mrgn_acct_id: GenericIdentification165,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntraDayCall") )]
	pub intra_day_call: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TmStmp") )]
	pub tm_stmp: String,
}

impl IntraDayMarginCall1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.mrgn_acct_id.validate()?;
		self.intra_day_call.validate()?;
		Ok(())
	}
}


// IntraDayRequirement1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IntraDayRequirement1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntraDayMrgnCall") )]
	pub intra_day_mrgn_call: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PeakInitlMrgnLblty") )]
	pub peak_initl_mrgn_lblty: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PeakVartnMrgnLblty") )]
	pub peak_vartn_mrgn_lblty: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AggtPeakLblty") )]
	pub aggt_peak_lblty: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MrgnAcctId") )]
	pub mrgn_acct_id: GenericIdentification165,
}

impl IntraDayRequirement1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.intra_day_mrgn_call.validate()?;
		self.peak_initl_mrgn_lblty.validate()?;
		self.peak_vartn_mrgn_lblty.validate()?;
		self.aggt_peak_lblty.validate()?;
		self.mrgn_acct_id.validate()?;
		Ok(())
	}
}


// InvestigatedParties1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestigatedParties1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<InvestigatedParties1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl InvestigatedParties1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// InvestigatedParties1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum InvestigatedParties1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ALLP") )]
	CodeALLP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OWNE") )]
	CodeOWNE,
}

impl InvestigatedParties1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// InvestigationActionReason1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestigationActionReason1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Orgtr", skip_serializing_if = "Option::is_none") )]
	pub orgtr: Option<PartyIdentification135>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn") )]
	pub rsn: InvestigationActionReason1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<Vec<String>>,
}

impl InvestigationActionReason1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgtr { val.validate()? }
		self.rsn.validate()?;
		if let Some(ref vec) = self.addtl_inf {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 105 {
					return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 105".to_string()));
				}
			}
		}
		Ok(())
	}
}


// InvestigationActionReason1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestigationActionReason1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl InvestigationActionReason1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// InvestigationData2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestigationData2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlInvstgtnSeq", skip_serializing_if = "Option::is_none") )]
	pub orgnl_invstgtn_seq: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlInvstgtnRsn", skip_serializing_if = "Option::is_none") )]
	pub orgnl_invstgtn_rsn: Option<InvestigationReason1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlInvstgtnRsnSubTp", skip_serializing_if = "Option::is_none") )]
	pub orgnl_invstgtn_rsn_sub_tp: Option<InvestigationReasonSubType1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RspnData") )]
	pub rspn_data: InvestigationDataRecord1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdInvstgtnData", skip_serializing_if = "Option::is_none") )]
	pub rltd_invstgtn_data: Option<RelatedInvestigationData1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NclsdFile", skip_serializing_if = "Option::is_none") )]
	pub nclsd_file: Option<Vec<Document12>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdFileData", skip_serializing_if = "Option::is_none") )]
	pub rltd_file_data: Option<Vec<FileData1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RspnOrgtr", skip_serializing_if = "Option::is_none") )]
	pub rspn_orgtr: Option<Party40Choice>,
}

impl InvestigationData2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgnl_invstgtn_rsn { val.validate()? }
		if let Some(ref val) = self.orgnl_invstgtn_rsn_sub_tp { val.validate()? }
		self.rspn_data.validate()?;
		if let Some(ref val) = self.rltd_invstgtn_data { val.validate()? }
		if let Some(ref vec) = self.nclsd_file { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.rltd_file_data { for item in vec { item.validate()? } }
		if let Some(ref val) = self.rspn_orgtr { val.validate()? }
		Ok(())
	}
}


// InvestigationDataRecord1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestigationDataRecord1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtAuthstn", skip_serializing_if = "Option::is_none") )]
	pub dbt_authstn: Option<DebitAuthorisationConfirmation3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Compstn", skip_serializing_if = "Option::is_none") )]
	pub compstn: Option<CompensationResponse1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Valtn", skip_serializing_if = "Option::is_none") )]
	pub valtn: Option<AdjustmentCompensation1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Conf", skip_serializing_if = "Option::is_none") )]
	pub conf: Option<BookingConfirmation1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxSts", skip_serializing_if = "Option::is_none") )]
	pub tx_sts: Option<PaymentTransactionStatus1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxData", skip_serializing_if = "Option::is_none") )]
	pub tx_data: Option<Vec<TransactionAmendment1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RspnNrrtv", skip_serializing_if = "Option::is_none") )]
	pub rspn_nrrtv: Option<String>,
}

impl InvestigationDataRecord1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.dbt_authstn { val.validate()? }
		if let Some(ref val) = self.compstn { val.validate()? }
		if let Some(ref val) = self.valtn { val.validate()? }
		if let Some(ref val) = self.conf { val.validate()? }
		if let Some(ref val) = self.tx_sts { val.validate()? }
		if let Some(ref vec) = self.tx_data { for item in vec { item.validate()? } }
		if let Some(ref val) = self.rspn_nrrtv {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rspn_nrrtv is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 500 {
				return Err(ValidationError::new(1002, "rspn_nrrtv exceeds the maximum length of 500".to_string()));
			}
		}
		Ok(())
	}
}


// InvestigationLocationData1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestigationLocationData1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mtd") )]
	pub mtd: InvestigationLocationMethod1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ElctrncAdr", skip_serializing_if = "Option::is_none") )]
	pub elctrnc_adr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstlAdr", skip_serializing_if = "Option::is_none") )]
	pub pstl_adr: Option<NameAndAddress16>,
}

impl InvestigationLocationData1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.mtd.validate()?;
		if let Some(ref val) = self.elctrnc_adr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "elctrnc_adr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 2048 {
				return Err(ValidationError::new(1002, "elctrnc_adr exceeds the maximum length of 2048".to_string()));
			}
		}
		if let Some(ref val) = self.pstl_adr { val.validate()? }
		Ok(())
	}
}


// InvestigationLocationMethod1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum InvestigationLocationMethod1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "EDIC") )]
	CodeEDIC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EMAL") )]
	CodeEMAL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FAXI") )]
	CodeFAXI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "POST") )]
	CodePOST,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SMSM") )]
	CodeSMSM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "URID") )]
	CodeURID,
}

impl InvestigationLocationMethod1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// InvestigationReason1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestigationReason1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl InvestigationReason1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// InvestigationReason2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestigationReason2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Seq", skip_serializing_if = "Option::is_none") )]
	pub seq: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn") )]
	pub rsn: InvestigationReason1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RsnSubTp", skip_serializing_if = "Option::is_none") )]
	pub rsn_sub_tp: Option<InvestigationReasonSubType1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlReqData", skip_serializing_if = "Option::is_none") )]
	pub addtl_req_data: Option<AdditionalRequestData1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdInvstgtnData", skip_serializing_if = "Option::is_none") )]
	pub rltd_invstgtn_data: Option<RelatedInvestigationData1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NclsdFile", skip_serializing_if = "Option::is_none") )]
	pub nclsd_file: Option<Vec<Document12>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdFileData", skip_serializing_if = "Option::is_none") )]
	pub rltd_file_data: Option<Vec<FileData1>>,
}

impl InvestigationReason2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.rsn.validate()?;
		if let Some(ref val) = self.rsn_sub_tp { val.validate()? }
		if let Some(ref val) = self.addtl_req_data { val.validate()? }
		if let Some(ref val) = self.rltd_invstgtn_data { val.validate()? }
		if let Some(ref vec) = self.nclsd_file { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.rltd_file_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// InvestigationReasonSubType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestigationReasonSubType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl InvestigationReasonSubType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// InvestigationRejection1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum InvestigationRejection1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "NFND") )]
	CodeNFND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NAUT") )]
	CodeNAUT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UKNW") )]
	CodeUKNW,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PCOR") )]
	CodePCOR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WMSG") )]
	CodeWMSG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RNCR") )]
	CodeRNCR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MROI") )]
	CodeMROI,
}

impl InvestigationRejection1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// InvestigationRejectionJustification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestigationRejectionJustification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RjctnRsn") )]
	pub rjctn_rsn: InvestigationRejection1Code,
}

impl InvestigationRejectionJustification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.rjctn_rsn.validate()?;
		Ok(())
	}
}


// InvestigationRequest2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestigationRequest2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RqstrInvstgtnId", skip_serializing_if = "Option::is_none") )]
	pub rqstr_invstgtn_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RspndrInvstgtnId", skip_serializing_if = "Option::is_none") )]
	pub rspndr_invstgtn_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EIR", skip_serializing_if = "Option::is_none") )]
	pub eir: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqActn", skip_serializing_if = "Option::is_none") )]
	pub req_actn: Option<InvestigationRequestAction1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstgtnTp") )]
	pub invstgtn_tp: InvestigationType1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstgtnSubTp", skip_serializing_if = "Option::is_none") )]
	pub invstgtn_sub_tp: Option<InvestigationSubType1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UndrlygInstrm", skip_serializing_if = "Option::is_none") )]
	pub undrlyg_instrm: Option<UnderlyingInvestigationInstrument1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Undrlyg") )]
	pub undrlyg: UnderlyingData2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rqstr") )]
	pub rqstr: Party40Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rspndr") )]
	pub rspndr: Party40Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqOrgtr", skip_serializing_if = "Option::is_none") )]
	pub req_orgtr: Option<Party40Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XpctdRspndr", skip_serializing_if = "Option::is_none") )]
	pub xpctd_rspndr: Option<Party40Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SvcLvl", skip_serializing_if = "Option::is_none") )]
	pub svc_lvl: Option<Vec<InvestigationServiceLevel1Choice>>,
}

impl InvestigationRequest2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.rqstr_invstgtn_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rqstr_invstgtn_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "rqstr_invstgtn_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.rspndr_invstgtn_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rspndr_invstgtn_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "rspndr_invstgtn_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.eir {
			let pattern = Regex::new("[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "eir does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.req_actn { val.validate()? }
		self.invstgtn_tp.validate()?;
		if let Some(ref val) = self.invstgtn_sub_tp { val.validate()? }
		if let Some(ref val) = self.undrlyg_instrm { val.validate()? }
		self.undrlyg.validate()?;
		self.rqstr.validate()?;
		self.rspndr.validate()?;
		if let Some(ref val) = self.req_orgtr { val.validate()? }
		if let Some(ref val) = self.xpctd_rspndr { val.validate()? }
		if let Some(ref vec) = self.svc_lvl { for item in vec { item.validate()? } }
		Ok(())
	}
}


// InvestigationRequest3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestigationRequest3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RqstrInvstgtnId", skip_serializing_if = "Option::is_none") )]
	pub rqstr_invstgtn_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RspndrInvstgtnId", skip_serializing_if = "Option::is_none") )]
	pub rspndr_invstgtn_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EIR", skip_serializing_if = "Option::is_none") )]
	pub eir: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqActn", skip_serializing_if = "Option::is_none") )]
	pub req_actn: Option<InvestigationRequestAction1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstgtnTp") )]
	pub invstgtn_tp: InvestigationType1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstgtnSubTp", skip_serializing_if = "Option::is_none") )]
	pub invstgtn_sub_tp: Option<InvestigationSubType1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UndrlygInstrm", skip_serializing_if = "Option::is_none") )]
	pub undrlyg_instrm: Option<UnderlyingInvestigationInstrument1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Undrlyg", skip_serializing_if = "Option::is_none") )]
	pub undrlyg: Option<UnderlyingData2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rqstr") )]
	pub rqstr: Party40Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rspndr") )]
	pub rspndr: Party40Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqOrgtr", skip_serializing_if = "Option::is_none") )]
	pub req_orgtr: Option<Party40Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XpctdRspndr", skip_serializing_if = "Option::is_none") )]
	pub xpctd_rspndr: Option<Party40Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SvcLvl", skip_serializing_if = "Option::is_none") )]
	pub svc_lvl: Option<Vec<InvestigationServiceLevel1Choice>>,
}

impl InvestigationRequest3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.rqstr_invstgtn_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rqstr_invstgtn_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "rqstr_invstgtn_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.rspndr_invstgtn_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rspndr_invstgtn_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "rspndr_invstgtn_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.eir {
			let pattern = Regex::new("[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "eir does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.req_actn { val.validate()? }
		self.invstgtn_tp.validate()?;
		if let Some(ref val) = self.invstgtn_sub_tp { val.validate()? }
		if let Some(ref val) = self.undrlyg_instrm { val.validate()? }
		if let Some(ref val) = self.undrlyg { val.validate()? }
		self.rqstr.validate()?;
		self.rspndr.validate()?;
		if let Some(ref val) = self.req_orgtr { val.validate()? }
		if let Some(ref val) = self.xpctd_rspndr { val.validate()? }
		if let Some(ref vec) = self.svc_lvl { for item in vec { item.validate()? } }
		Ok(())
	}
}


// InvestigationRequestAction1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestigationRequestAction1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Actn") )]
	pub actn: InvestigationRequestAction1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ActnRsn", skip_serializing_if = "Option::is_none") )]
	pub actn_rsn: Option<InvestigationActionReason1>,
}

impl InvestigationRequestAction1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.actn.validate()?;
		if let Some(ref val) = self.actn_rsn { val.validate()? }
		Ok(())
	}
}


// InvestigationRequestAction1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestigationRequestAction1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl InvestigationRequestAction1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// InvestigationResponse3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestigationResponse3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RspndrInvstgtnId", skip_serializing_if = "Option::is_none") )]
	pub rspndr_invstgtn_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstgtnSts") )]
	pub invstgtn_sts: InvestigationStatus2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NxtRspndr", skip_serializing_if = "Option::is_none") )]
	pub nxt_rspndr: Option<Party40Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstgtnData", skip_serializing_if = "Option::is_none") )]
	pub invstgtn_data: Option<Vec<InvestigationData2>>,
}

impl InvestigationResponse3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.rspndr_invstgtn_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rspndr_invstgtn_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "rspndr_invstgtn_id exceeds the maximum length of 35".to_string()));
			}
		}
		self.invstgtn_sts.validate()?;
		if let Some(ref val) = self.nxt_rspndr { val.validate()? }
		if let Some(ref vec) = self.invstgtn_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// InvestigationResult1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestigationResult1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rslt", skip_serializing_if = "Option::is_none") )]
	pub rslt: Option<SupplementaryDataEnvelope1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstgtnSts", skip_serializing_if = "Option::is_none") )]
	pub invstgtn_sts: Option<InvestigationStatus1Code>,
}

impl InvestigationResult1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rslt { val.validate()? }
		if let Some(ref val) = self.invstgtn_sts { val.validate()? }
		Ok(())
	}
}


// InvestigationServiceLevel1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestigationServiceLevel1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl InvestigationServiceLevel1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// InvestigationStatus1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum InvestigationStatus1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "FOUN") )]
	CodeFOUN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NFOU") )]
	CodeNFOU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NOAP") )]
	CodeNOAP,
}

impl InvestigationStatus1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// InvestigationStatus2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestigationStatus2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts") )]
	pub sts: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsRsn", skip_serializing_if = "Option::is_none") )]
	pub sts_rsn: Option<InvestigationStatusReason1Choice>,
}

impl InvestigationStatus2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.sts.chars().count() < 1 {
			return Err(ValidationError::new(1001, "sts is shorter than the minimum length of 1".to_string()));
		}
		if self.sts.chars().count() > 4 {
			return Err(ValidationError::new(1002, "sts exceeds the maximum length of 4".to_string()));
		}
		if let Some(ref val) = self.sts_rsn { val.validate()? }
		Ok(())
	}
}


// InvestigationStatus6Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestigationStatus6Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Conf", skip_serializing_if = "Option::is_none") )]
	pub conf: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RjctdMod", skip_serializing_if = "Option::is_none") )]
	pub rjctd_mod: Option<Vec<ModificationStatusReason1Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DplctOf", skip_serializing_if = "Option::is_none") )]
	pub dplct_of: Option<Case6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AssgnmtCxlConf", skip_serializing_if = "Option::is_none") )]
	pub assgnmt_cxl_conf: Option<bool>,
}

impl InvestigationStatus6Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.conf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "conf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "conf exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref vec) = self.rjctd_mod { for item in vec { item.validate()? } }
		if let Some(ref val) = self.dplct_of { val.validate()? }
		Ok(())
	}
}


// InvestigationStatusReason1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestigationStatusReason1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl InvestigationStatusReason1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// InvestigationSubType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestigationSubType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl InvestigationSubType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// InvestigationType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestigationType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl InvestigationType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// Investment1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Investment1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "UscrdCshDpst", skip_serializing_if = "Option::is_none") )]
	pub uscrd_csh_dpst: Option<Deposit1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CntrlBkDpst", skip_serializing_if = "Option::is_none") )]
	pub cntrl_bk_dpst: Option<Deposit1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RpAgrmt", skip_serializing_if = "Option::is_none") )]
	pub rp_agrmt: Option<RepurchaseAgreement2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrInvstmts", skip_serializing_if = "Option::is_none") )]
	pub othr_invstmts: Option<OtherInvestment1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OutrghtInvstmt", skip_serializing_if = "Option::is_none") )]
	pub outrght_invstmt: Option<SecurityIdentificationAndAmount1>,
}

impl Investment1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.uscrd_csh_dpst { val.validate()? }
		if let Some(ref val) = self.cntrl_bk_dpst { val.validate()? }
		if let Some(ref val) = self.rp_agrmt { val.validate()? }
		if let Some(ref val) = self.othr_invstmts { val.validate()? }
		if let Some(ref val) = self.outrght_invstmt { val.validate()? }
		Ok(())
	}
}


// InvestmentAccount42 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestmentAccount42 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctId", skip_serializing_if = "Option::is_none") )]
	pub acct_id: Option<AccountIdentification1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OwnrId", skip_serializing_if = "Option::is_none") )]
	pub ownr_id: Option<PartyIdentification2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcr", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr: Option<PartyIdentification2Choice>,
}

impl InvestmentAccount42 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.acct_id { val.validate()? }
		if let Some(ref val) = self.ownr_id { val.validate()? }
		if let Some(ref val) = self.acct_svcr { val.validate()? }
		Ok(())
	}
}


// InvestmentAccount73 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestmentAccount73 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dsgnt", skip_serializing_if = "Option::is_none") )]
	pub dsgnt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<AccountType2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OwnrshTp") )]
	pub ownrsh_tp: OwnershipType2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxXmptn", skip_serializing_if = "Option::is_none") )]
	pub tax_xmptn: Option<TaxExemptionReason2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StmtFrqcy", skip_serializing_if = "Option::is_none") )]
	pub stmt_frqcy: Option<StatementFrequencyReason2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RefCcy", skip_serializing_if = "Option::is_none") )]
	pub ref_ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Lang", skip_serializing_if = "Option::is_none") )]
	pub lang: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IncmPref", skip_serializing_if = "Option::is_none") )]
	pub incm_pref: Option<IncomePreference2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RinvstmtDtls", skip_serializing_if = "Option::is_none") )]
	pub rinvstmt_dtls: Option<Vec<Reinvestment4>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxWhldgMtd", skip_serializing_if = "Option::is_none") )]
	pub tax_whldg_mtd: Option<TaxWithholdingMethod3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxRptg", skip_serializing_if = "Option::is_none") )]
	pub tax_rptg: Option<Vec<TaxReporting3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LttrInttDtls", skip_serializing_if = "Option::is_none") )]
	pub lttr_intt_dtls: Option<LetterIntent1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcmltnRghtRef", skip_serializing_if = "Option::is_none") )]
	pub acmltn_rght_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqrdSgntriesNb", skip_serializing_if = "Option::is_none") )]
	pub reqrd_sgntries_nb: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FndFmlyNm", skip_serializing_if = "Option::is_none") )]
	pub fnd_fmly_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmDtls", skip_serializing_if = "Option::is_none") )]
	pub fin_instrm_dtls: Option<Vec<FinancialInstrument87>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RndgDtls", skip_serializing_if = "Option::is_none") )]
	pub rndg_dtls: Option<RoundingParameters1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcr", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr: Option<PartyIdentification125Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BlckdSts", skip_serializing_if = "Option::is_none") )]
	pub blckd_sts: Option<BlockedStatusReason2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctUsgTp", skip_serializing_if = "Option::is_none") )]
	pub acct_usg_tp: Option<AccountUsageType2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrgnStsCertfctn", skip_serializing_if = "Option::is_none") )]
	pub frgn_sts_certfctn: Option<Provided1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSgntrDtTm", skip_serializing_if = "Option::is_none") )]
	pub acct_sgntr_dt_tm: Option<DateAndDateTime1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxChanlTp", skip_serializing_if = "Option::is_none") )]
	pub tx_chanl_tp: Option<TransactionChannelType1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstmtAcctCtgy", skip_serializing_if = "Option::is_none") )]
	pub invstmt_acct_ctgy: Option<InvestmentAccountCategory1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pldgg", skip_serializing_if = "Option::is_none") )]
	pub pldgg: Option<Eligible1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Coll", skip_serializing_if = "Option::is_none") )]
	pub coll: Option<Collateral1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ThrdPtyRghts", skip_serializing_if = "Option::is_none") )]
	pub thrd_pty_rghts: Option<ThirdPartyRights2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PwrOfAttnyLvlOfCtrl", skip_serializing_if = "Option::is_none") )]
	pub pwr_of_attny_lvl_of_ctrl: Option<LevelOfControl1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctgSts", skip_serializing_if = "Option::is_none") )]
	pub acctg_sts: Option<AccountingStatus1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OpngDt", skip_serializing_if = "Option::is_none") )]
	pub opng_dt: Option<DateAndDateTime1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClsgDt", skip_serializing_if = "Option::is_none") )]
	pub clsg_dt: Option<DateAndDateTime1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NegInd", skip_serializing_if = "Option::is_none") )]
	pub neg_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrcgOrdr", skip_serializing_if = "Option::is_none") )]
	pub prcg_ordr: Option<PositionEffect3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Lblty", skip_serializing_if = "Option::is_none") )]
	pub lblty: Option<Liability1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstrPrfl", skip_serializing_if = "Option::is_none") )]
	pub invstr_prfl: Option<Vec<InvestorProfile2>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FsclYr", skip_serializing_if = "Option::is_none") )]
	pub fscl_yr: Option<FiscalYear1Choice>,
}

impl InvestmentAccount73 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.dsgnt {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "dsgnt is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "dsgnt exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.tp { val.validate()? }
		self.ownrsh_tp.validate()?;
		if let Some(ref val) = self.tax_xmptn { val.validate()? }
		if let Some(ref val) = self.stmt_frqcy { val.validate()? }
		if let Some(ref val) = self.ref_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ref_ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.incm_pref { val.validate()? }
		if let Some(ref vec) = self.rinvstmt_dtls { for item in vec { item.validate()? } }
		if let Some(ref val) = self.tax_whldg_mtd { val.validate()? }
		if let Some(ref vec) = self.tax_rptg { for item in vec { item.validate()? } }
		if let Some(ref val) = self.lttr_intt_dtls { val.validate()? }
		if let Some(ref val) = self.acmltn_rght_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acmltn_rght_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acmltn_rght_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.fnd_fmly_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "fnd_fmly_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "fnd_fmly_nm exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref vec) = self.fin_instrm_dtls { for item in vec { item.validate()? } }
		if let Some(ref val) = self.rndg_dtls { val.validate()? }
		if let Some(ref val) = self.acct_svcr { val.validate()? }
		if let Some(ref val) = self.blckd_sts { val.validate()? }
		if let Some(ref val) = self.acct_usg_tp { val.validate()? }
		if let Some(ref val) = self.frgn_sts_certfctn { val.validate()? }
		if let Some(ref val) = self.acct_sgntr_dt_tm { val.validate()? }
		if let Some(ref val) = self.tx_chanl_tp { val.validate()? }
		if let Some(ref val) = self.invstmt_acct_ctgy { val.validate()? }
		if let Some(ref val) = self.pldgg { val.validate()? }
		if let Some(ref val) = self.coll { val.validate()? }
		if let Some(ref val) = self.thrd_pty_rghts { val.validate()? }
		if let Some(ref val) = self.pwr_of_attny_lvl_of_ctrl { val.validate()? }
		if let Some(ref val) = self.acctg_sts { val.validate()? }
		if let Some(ref val) = self.opng_dt { val.validate()? }
		if let Some(ref val) = self.clsg_dt { val.validate()? }
		if let Some(ref val) = self.prcg_ordr { val.validate()? }
		if let Some(ref val) = self.lblty { val.validate()? }
		if let Some(ref vec) = self.invstr_prfl { for item in vec { item.validate()? } }
		if let Some(ref val) = self.fscl_yr { val.validate()? }
		Ok(())
	}
}


// InvestmentAccount74 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestmentAccount74 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSts", skip_serializing_if = "Option::is_none") )]
	pub acct_sts: Option<AccountStatus2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BlckdSts", skip_serializing_if = "Option::is_none") )]
	pub blckd_sts: Option<BlockedStatusReason2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsDt", skip_serializing_if = "Option::is_none") )]
	pub sts_dt: Option<DateAndDateTime1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dsgnt", skip_serializing_if = "Option::is_none") )]
	pub dsgnt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<AccountType2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OwnrshTp", skip_serializing_if = "Option::is_none") )]
	pub ownrsh_tp: Option<OwnershipType2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxXmptn", skip_serializing_if = "Option::is_none") )]
	pub tax_xmptn: Option<TaxExemptionReason2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StmtFrqcy", skip_serializing_if = "Option::is_none") )]
	pub stmt_frqcy: Option<StatementFrequencyReason2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RefCcy", skip_serializing_if = "Option::is_none") )]
	pub ref_ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Lang", skip_serializing_if = "Option::is_none") )]
	pub lang: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IncmPref", skip_serializing_if = "Option::is_none") )]
	pub incm_pref: Option<IncomePreference2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RinvstmtDtls", skip_serializing_if = "Option::is_none") )]
	pub rinvstmt_dtls: Option<Vec<Reinvestment4>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxWhldgMtd", skip_serializing_if = "Option::is_none") )]
	pub tax_whldg_mtd: Option<TaxWithholdingMethod3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxRptg", skip_serializing_if = "Option::is_none") )]
	pub tax_rptg: Option<Vec<TaxReporting3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LttrInttDtls", skip_serializing_if = "Option::is_none") )]
	pub lttr_intt_dtls: Option<LetterIntent1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcmltnRghtRef", skip_serializing_if = "Option::is_none") )]
	pub acmltn_rght_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqrdSgntriesNb", skip_serializing_if = "Option::is_none") )]
	pub reqrd_sgntries_nb: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FndFmlyNm", skip_serializing_if = "Option::is_none") )]
	pub fnd_fmly_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmDtls", skip_serializing_if = "Option::is_none") )]
	pub fin_instrm_dtls: Option<Vec<FinancialInstrument87>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RndgDtls", skip_serializing_if = "Option::is_none") )]
	pub rndg_dtls: Option<RoundingParameters1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcr", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr: Option<PartyIdentification125Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctUsgTp", skip_serializing_if = "Option::is_none") )]
	pub acct_usg_tp: Option<AccountUsageType2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrgnStsCertfctn", skip_serializing_if = "Option::is_none") )]
	pub frgn_sts_certfctn: Option<Provided1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSgntrDtTm", skip_serializing_if = "Option::is_none") )]
	pub acct_sgntr_dt_tm: Option<DateAndDateTime1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxChanlTp", skip_serializing_if = "Option::is_none") )]
	pub tx_chanl_tp: Option<TransactionChannelType1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstmtAcctCtgy", skip_serializing_if = "Option::is_none") )]
	pub invstmt_acct_ctgy: Option<InvestmentAccountCategory1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pldgg", skip_serializing_if = "Option::is_none") )]
	pub pldgg: Option<Eligible1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Coll", skip_serializing_if = "Option::is_none") )]
	pub coll: Option<Collateral1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ThrdPtyRghts", skip_serializing_if = "Option::is_none") )]
	pub thrd_pty_rghts: Option<ThirdPartyRights2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PwrOfAttnyLvlOfCtrl", skip_serializing_if = "Option::is_none") )]
	pub pwr_of_attny_lvl_of_ctrl: Option<LevelOfControl1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctgSts", skip_serializing_if = "Option::is_none") )]
	pub acctg_sts: Option<AccountingStatus1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OpngDt", skip_serializing_if = "Option::is_none") )]
	pub opng_dt: Option<DateAndDateTime1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClsgDt", skip_serializing_if = "Option::is_none") )]
	pub clsg_dt: Option<DateAndDateTime1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NegInd", skip_serializing_if = "Option::is_none") )]
	pub neg_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrcgOrdr", skip_serializing_if = "Option::is_none") )]
	pub prcg_ordr: Option<PositionEffect3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Lblty", skip_serializing_if = "Option::is_none") )]
	pub lblty: Option<Liability1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstrPrfl", skip_serializing_if = "Option::is_none") )]
	pub invstr_prfl: Option<Vec<InvestorProfile2>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FsclYr", skip_serializing_if = "Option::is_none") )]
	pub fscl_yr: Option<FiscalYear1Choice>,
}

impl InvestmentAccount74 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.acct_sts { val.validate()? }
		if let Some(ref val) = self.blckd_sts { val.validate()? }
		if let Some(ref val) = self.sts_dt { val.validate()? }
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.dsgnt {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "dsgnt is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "dsgnt exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.ownrsh_tp { val.validate()? }
		if let Some(ref val) = self.tax_xmptn { val.validate()? }
		if let Some(ref val) = self.stmt_frqcy { val.validate()? }
		if let Some(ref val) = self.ref_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ref_ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.incm_pref { val.validate()? }
		if let Some(ref vec) = self.rinvstmt_dtls { for item in vec { item.validate()? } }
		if let Some(ref val) = self.tax_whldg_mtd { val.validate()? }
		if let Some(ref vec) = self.tax_rptg { for item in vec { item.validate()? } }
		if let Some(ref val) = self.lttr_intt_dtls { val.validate()? }
		if let Some(ref val) = self.acmltn_rght_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acmltn_rght_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acmltn_rght_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.fnd_fmly_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "fnd_fmly_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "fnd_fmly_nm exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref vec) = self.fin_instrm_dtls { for item in vec { item.validate()? } }
		if let Some(ref val) = self.rndg_dtls { val.validate()? }
		if let Some(ref val) = self.acct_svcr { val.validate()? }
		if let Some(ref val) = self.acct_usg_tp { val.validate()? }
		if let Some(ref val) = self.frgn_sts_certfctn { val.validate()? }
		if let Some(ref val) = self.acct_sgntr_dt_tm { val.validate()? }
		if let Some(ref val) = self.tx_chanl_tp { val.validate()? }
		if let Some(ref val) = self.invstmt_acct_ctgy { val.validate()? }
		if let Some(ref val) = self.pldgg { val.validate()? }
		if let Some(ref val) = self.coll { val.validate()? }
		if let Some(ref val) = self.thrd_pty_rghts { val.validate()? }
		if let Some(ref val) = self.pwr_of_attny_lvl_of_ctrl { val.validate()? }
		if let Some(ref val) = self.acctg_sts { val.validate()? }
		if let Some(ref val) = self.opng_dt { val.validate()? }
		if let Some(ref val) = self.clsg_dt { val.validate()? }
		if let Some(ref val) = self.prcg_ordr { val.validate()? }
		if let Some(ref val) = self.lblty { val.validate()? }
		if let Some(ref vec) = self.invstr_prfl { for item in vec { item.validate()? } }
		if let Some(ref val) = self.fscl_yr { val.validate()? }
		Ok(())
	}
}


// InvestmentAccount75 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestmentAccount75 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctStsUpdInstr", skip_serializing_if = "Option::is_none") )]
	pub acct_sts_upd_instr: Option<AccountStatusUpdateInstruction1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dsgnt", skip_serializing_if = "Option::is_none") )]
	pub dsgnt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<AccountType2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OwnrshTp", skip_serializing_if = "Option::is_none") )]
	pub ownrsh_tp: Option<OwnershipType2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxXmptn", skip_serializing_if = "Option::is_none") )]
	pub tax_xmptn: Option<TaxExemptionReason2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StmtFrqcy", skip_serializing_if = "Option::is_none") )]
	pub stmt_frqcy: Option<StatementFrequencyReason2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RefCcy", skip_serializing_if = "Option::is_none") )]
	pub ref_ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Lang", skip_serializing_if = "Option::is_none") )]
	pub lang: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IncmPref", skip_serializing_if = "Option::is_none") )]
	pub incm_pref: Option<IncomePreference2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RinvstmtDtls", skip_serializing_if = "Option::is_none") )]
	pub rinvstmt_dtls: Option<Vec<Reinvestment4>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxWhldgMtd", skip_serializing_if = "Option::is_none") )]
	pub tax_whldg_mtd: Option<TaxWithholdingMethod3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxRptg", skip_serializing_if = "Option::is_none") )]
	pub tax_rptg: Option<Vec<TaxReporting3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LttrInttDtls", skip_serializing_if = "Option::is_none") )]
	pub lttr_intt_dtls: Option<LetterIntent1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcmltnRghtRef", skip_serializing_if = "Option::is_none") )]
	pub acmltn_rght_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqrdSgntriesNb", skip_serializing_if = "Option::is_none") )]
	pub reqrd_sgntries_nb: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FndFmlyNm", skip_serializing_if = "Option::is_none") )]
	pub fnd_fmly_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModfdFinInstrmDtls", skip_serializing_if = "Option::is_none") )]
	pub modfd_fin_instrm_dtls: Option<Vec<ModificationScope42>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RndgDtls", skip_serializing_if = "Option::is_none") )]
	pub rndg_dtls: Option<RoundingParameters1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcr", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr: Option<PartyIdentification125Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BlckdSts", skip_serializing_if = "Option::is_none") )]
	pub blckd_sts: Option<BlockedStatusReason2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctUsgTp", skip_serializing_if = "Option::is_none") )]
	pub acct_usg_tp: Option<AccountUsageType2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrgnStsCertfctn", skip_serializing_if = "Option::is_none") )]
	pub frgn_sts_certfctn: Option<Provided1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSgntrDtTm", skip_serializing_if = "Option::is_none") )]
	pub acct_sgntr_dt_tm: Option<DateAndDateTime1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxChanlTp", skip_serializing_if = "Option::is_none") )]
	pub tx_chanl_tp: Option<TransactionChannelType1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstmtAcctCtgy", skip_serializing_if = "Option::is_none") )]
	pub invstmt_acct_ctgy: Option<InvestmentAccountCategory1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pldgg", skip_serializing_if = "Option::is_none") )]
	pub pldgg: Option<Eligible1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Coll", skip_serializing_if = "Option::is_none") )]
	pub coll: Option<Collateral1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ThrdPtyRghts", skip_serializing_if = "Option::is_none") )]
	pub thrd_pty_rghts: Option<ThirdPartyRights2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PwrOfAttnyLvlOfCtrl", skip_serializing_if = "Option::is_none") )]
	pub pwr_of_attny_lvl_of_ctrl: Option<LevelOfControl1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctgSts", skip_serializing_if = "Option::is_none") )]
	pub acctg_sts: Option<AccountingStatus1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OpngDt", skip_serializing_if = "Option::is_none") )]
	pub opng_dt: Option<DateAndDateTime1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClsgDt", skip_serializing_if = "Option::is_none") )]
	pub clsg_dt: Option<DateAndDateTime1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NegInd", skip_serializing_if = "Option::is_none") )]
	pub neg_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrcgOrdr", skip_serializing_if = "Option::is_none") )]
	pub prcg_ordr: Option<PositionEffect3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Lblty", skip_serializing_if = "Option::is_none") )]
	pub lblty: Option<Liability1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModfdInvstrPrfl", skip_serializing_if = "Option::is_none") )]
	pub modfd_invstr_prfl: Option<Vec<ModificationScope46>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FsclYr", skip_serializing_if = "Option::is_none") )]
	pub fscl_yr: Option<FiscalYear1Choice>,
}

impl InvestmentAccount75 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.acct_sts_upd_instr { val.validate()? }
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.dsgnt {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "dsgnt is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "dsgnt exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.ownrsh_tp { val.validate()? }
		if let Some(ref val) = self.tax_xmptn { val.validate()? }
		if let Some(ref val) = self.stmt_frqcy { val.validate()? }
		if let Some(ref val) = self.ref_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ref_ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.incm_pref { val.validate()? }
		if let Some(ref vec) = self.rinvstmt_dtls { for item in vec { item.validate()? } }
		if let Some(ref val) = self.tax_whldg_mtd { val.validate()? }
		if let Some(ref vec) = self.tax_rptg { for item in vec { item.validate()? } }
		if let Some(ref val) = self.lttr_intt_dtls { val.validate()? }
		if let Some(ref val) = self.acmltn_rght_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acmltn_rght_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acmltn_rght_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.fnd_fmly_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "fnd_fmly_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "fnd_fmly_nm exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref vec) = self.modfd_fin_instrm_dtls { for item in vec { item.validate()? } }
		if let Some(ref val) = self.rndg_dtls { val.validate()? }
		if let Some(ref val) = self.acct_svcr { val.validate()? }
		if let Some(ref val) = self.blckd_sts { val.validate()? }
		if let Some(ref val) = self.acct_usg_tp { val.validate()? }
		if let Some(ref val) = self.frgn_sts_certfctn { val.validate()? }
		if let Some(ref val) = self.acct_sgntr_dt_tm { val.validate()? }
		if let Some(ref val) = self.tx_chanl_tp { val.validate()? }
		if let Some(ref val) = self.invstmt_acct_ctgy { val.validate()? }
		if let Some(ref val) = self.pldgg { val.validate()? }
		if let Some(ref val) = self.coll { val.validate()? }
		if let Some(ref val) = self.thrd_pty_rghts { val.validate()? }
		if let Some(ref val) = self.pwr_of_attny_lvl_of_ctrl { val.validate()? }
		if let Some(ref val) = self.acctg_sts { val.validate()? }
		if let Some(ref val) = self.opng_dt { val.validate()? }
		if let Some(ref val) = self.clsg_dt { val.validate()? }
		if let Some(ref val) = self.prcg_ordr { val.validate()? }
		if let Some(ref val) = self.lblty { val.validate()? }
		if let Some(ref vec) = self.modfd_invstr_prfl { for item in vec { item.validate()? } }
		if let Some(ref val) = self.fscl_yr { val.validate()? }
		Ok(())
	}
}


// InvestmentAccount76 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestmentAccount76 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dsgnt", skip_serializing_if = "Option::is_none") )]
	pub dsgnt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FndTp", skip_serializing_if = "Option::is_none") )]
	pub fnd_tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FndFmlyNm", skip_serializing_if = "Option::is_none") )]
	pub fnd_fmly_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctyDtls", skip_serializing_if = "Option::is_none") )]
	pub scty_dtls: Option<FinancialInstrument55>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctOwnr", skip_serializing_if = "Option::is_none") )]
	pub acct_ownr: Option<AccountOwner3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Intrmy", skip_serializing_if = "Option::is_none") )]
	pub intrmy: Option<Vec<Intermediary47>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcr", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr: Option<PartyIdentification125Choice>,
}

impl InvestmentAccount76 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.dsgnt {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "dsgnt is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "dsgnt exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.fnd_tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "fnd_tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "fnd_tp exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.fnd_fmly_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "fnd_fmly_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "fnd_fmly_nm exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.scty_dtls { val.validate()? }
		if let Some(ref val) = self.acct_ownr { val.validate()? }
		if let Some(ref vec) = self.intrmy { for item in vec { item.validate()? } }
		if let Some(ref val) = self.acct_svcr { val.validate()? }
		Ok(())
	}
}


// InvestmentAccount77 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestmentAccount77 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctId") )]
	pub acct_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctNm", skip_serializing_if = "Option::is_none") )]
	pub acct_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctDsgnt", skip_serializing_if = "Option::is_none") )]
	pub acct_dsgnt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OwnrId", skip_serializing_if = "Option::is_none") )]
	pub ownr_id: Option<OwnerIdentification3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcr", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr: Option<PartyIdentification125Choice>,
}

impl InvestmentAccount77 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.acct_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "acct_id is shorter than the minimum length of 1".to_string()));
		}
		if self.acct_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "acct_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.acct_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acct_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.acct_dsgnt {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_dsgnt is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acct_dsgnt exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.ownr_id { val.validate()? }
		if let Some(ref val) = self.acct_svcr { val.validate()? }
		Ok(())
	}
}


// InvestmentAccountCategory1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestmentAccountCategory1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<InvestmentAccountCategory1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl InvestmentAccountCategory1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// InvestmentAccountCategory1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum InvestmentAccountCategory1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "MAND") )]
	CodeMAND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RETA") )]
	CodeRETA,
}

impl InvestmentAccountCategory1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// InvestmentAccountModification4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestmentAccountModification4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModRsn", skip_serializing_if = "Option::is_none") )]
	pub mod_rsn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctApplId", skip_serializing_if = "Option::is_none") )]
	pub acct_appl_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClntRef", skip_serializing_if = "Option::is_none") )]
	pub clnt_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtyRef", skip_serializing_if = "Option::is_none") )]
	pub ctr_pty_ref: Option<AdditionalReference13>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExstgAcctId", skip_serializing_if = "Option::is_none") )]
	pub exstg_acct_id: Option<Vec<Account23>>,
}

impl InvestmentAccountModification4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mod_rsn {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mod_rsn is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "mod_rsn exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.acct_appl_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_appl_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acct_appl_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.clnt_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "clnt_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "clnt_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.ctr_pty_ref { val.validate()? }
		if let Some(ref vec) = self.exstg_acct_id { for item in vec { item.validate()? } }
		Ok(())
	}
}


// InvestmentAccountOpening4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestmentAccountOpening4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OpngTp") )]
	pub opng_tp: AccountOpeningType1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctApplId", skip_serializing_if = "Option::is_none") )]
	pub acct_appl_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClntRef", skip_serializing_if = "Option::is_none") )]
	pub clnt_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtyRef", skip_serializing_if = "Option::is_none") )]
	pub ctr_pty_ref: Option<AdditionalReference13>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExstgAcctId", skip_serializing_if = "Option::is_none") )]
	pub exstg_acct_id: Option<Vec<Account23>>,
}

impl InvestmentAccountOpening4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.opng_tp.validate()?;
		if let Some(ref val) = self.acct_appl_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_appl_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acct_appl_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.clnt_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "clnt_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "clnt_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.ctr_pty_ref { val.validate()? }
		if let Some(ref vec) = self.exstg_acct_id { for item in vec { item.validate()? } }
		Ok(())
	}
}


// InvestmentAccountOwnershipInformation16 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestmentAccountOwnershipInformation16 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pty") )]
	pub pty: Party47Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MnyLndrgChck", skip_serializing_if = "Option::is_none") )]
	pub mny_lndrg_chck: Option<MoneyLaunderingCheck1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstrPrflVldtn", skip_serializing_if = "Option::is_none") )]
	pub invstr_prfl_vldtn: Option<Vec<PartyProfileInformation5>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OwnrshBnfcryRate", skip_serializing_if = "Option::is_none") )]
	pub ownrsh_bnfcry_rate: Option<OwnershipBeneficiaryRate1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClntId", skip_serializing_if = "Option::is_none") )]
	pub clnt_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FsclXmptn", skip_serializing_if = "Option::is_none") )]
	pub fscl_xmptn: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SgntryRghtInd", skip_serializing_if = "Option::is_none") )]
	pub sgntry_rght_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MiFIDClssfctn", skip_serializing_if = "Option::is_none") )]
	pub mi_fid_clssfctn: Option<MiFIDClassification1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ntfctn", skip_serializing_if = "Option::is_none") )]
	pub ntfctn: Option<Vec<Notification2>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FATCAFormTp", skip_serializing_if = "Option::is_none") )]
	pub fatca_form_tp: Option<Vec<FATCAForm1Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FATCASts", skip_serializing_if = "Option::is_none") )]
	pub fatca_sts: Option<Vec<FATCAStatus2>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FATCARptgDt", skip_serializing_if = "Option::is_none") )]
	pub fatca_rptg_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CRSFormTp", skip_serializing_if = "Option::is_none") )]
	pub crs_form_tp: Option<Vec<CRSForm1Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CRSSts", skip_serializing_if = "Option::is_none") )]
	pub crs_sts: Option<Vec<CRSStatus4>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CRSRptgDt", skip_serializing_if = "Option::is_none") )]
	pub crs_rptg_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrId", skip_serializing_if = "Option::is_none") )]
	pub othr_id: Option<Vec<GenericIdentification82>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxXmptn", skip_serializing_if = "Option::is_none") )]
	pub tax_xmptn: Option<TaxExemptionReason2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxRptg", skip_serializing_if = "Option::is_none") )]
	pub tax_rptg: Option<Vec<TaxReporting3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Lang", skip_serializing_if = "Option::is_none") )]
	pub lang: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MailTp", skip_serializing_if = "Option::is_none") )]
	pub mail_tp: Option<MailType1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtryAndResdtlSts", skip_serializing_if = "Option::is_none") )]
	pub ctry_and_resdtl_sts: Option<CountryAndResidentialStatusType2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MntryWlth", skip_serializing_if = "Option::is_none") )]
	pub mntry_wlth: Option<DateAndAmount1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EqtyVal", skip_serializing_if = "Option::is_none") )]
	pub eqty_val: Option<DateAndAmount1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WorkgCptl", skip_serializing_if = "Option::is_none") )]
	pub workg_cptl: Option<DateAndAmount1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CpnyLk", skip_serializing_if = "Option::is_none") )]
	pub cpny_lk: Option<CompanyLink1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ElctrncMlngSvcRef", skip_serializing_if = "Option::is_none") )]
	pub elctrnc_mlng_svc_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmryComAdr", skip_serializing_if = "Option::is_none") )]
	pub pmry_com_adr: Option<Vec<CommunicationAddress6>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ScndryComAdr", skip_serializing_if = "Option::is_none") )]
	pub scndry_com_adr: Option<Vec<CommunicationAddress6>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlRgltryInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_rgltry_inf: Option<RegulatoryInformation1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctgSts", skip_serializing_if = "Option::is_none") )]
	pub acctg_sts: Option<AccountingStatus1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<Vec<AdditiononalInformation13>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrlgPty", skip_serializing_if = "Option::is_none") )]
	pub ctrlg_pty: Option<bool>,
}

impl InvestmentAccountOwnershipInformation16 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pty.validate()?;
		if let Some(ref val) = self.mny_lndrg_chck { val.validate()? }
		if let Some(ref vec) = self.invstr_prfl_vldtn { for item in vec { item.validate()? } }
		if let Some(ref val) = self.ownrsh_bnfcry_rate { val.validate()? }
		if let Some(ref val) = self.clnt_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "clnt_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "clnt_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.mi_fid_clssfctn { val.validate()? }
		if let Some(ref vec) = self.ntfctn { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.fatca_form_tp { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.fatca_sts { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.crs_form_tp { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.crs_sts { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.othr_id { for item in vec { item.validate()? } }
		if let Some(ref val) = self.tax_xmptn { val.validate()? }
		if let Some(ref vec) = self.tax_rptg { for item in vec { item.validate()? } }
		if let Some(ref val) = self.mail_tp { val.validate()? }
		if let Some(ref val) = self.ctry_and_resdtl_sts { val.validate()? }
		if let Some(ref val) = self.mntry_wlth { val.validate()? }
		if let Some(ref val) = self.eqty_val { val.validate()? }
		if let Some(ref val) = self.workg_cptl { val.validate()? }
		if let Some(ref val) = self.cpny_lk { val.validate()? }
		if let Some(ref val) = self.elctrnc_mlng_svc_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "elctrnc_mlng_svc_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "elctrnc_mlng_svc_ref exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref vec) = self.pmry_com_adr { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.scndry_com_adr { for item in vec { item.validate()? } }
		if let Some(ref val) = self.addtl_rgltry_inf { val.validate()? }
		if let Some(ref val) = self.acctg_sts { val.validate()? }
		if let Some(ref vec) = self.addtl_inf { for item in vec { item.validate()? } }
		Ok(())
	}
}


// InvestmentAccountOwnershipInformation17 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestmentAccountOwnershipInformation17 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pty") )]
	pub pty: Party48Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MnyLndrgChck", skip_serializing_if = "Option::is_none") )]
	pub mny_lndrg_chck: Option<MoneyLaunderingCheck1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModfdInvstrPrflVldtn", skip_serializing_if = "Option::is_none") )]
	pub modfd_invstr_prfl_vldtn: Option<Vec<ModificationScope27>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OwnrshBnfcryRate", skip_serializing_if = "Option::is_none") )]
	pub ownrsh_bnfcry_rate: Option<OwnershipBeneficiaryRate1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClntId", skip_serializing_if = "Option::is_none") )]
	pub clnt_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FsclXmptn", skip_serializing_if = "Option::is_none") )]
	pub fscl_xmptn: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SgntryRghtInd", skip_serializing_if = "Option::is_none") )]
	pub sgntry_rght_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MiFIDClssfctn", skip_serializing_if = "Option::is_none") )]
	pub mi_fid_clssfctn: Option<MiFIDClassification1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ntfctn", skip_serializing_if = "Option::is_none") )]
	pub ntfctn: Option<Vec<Notification2>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FATCAFormTp", skip_serializing_if = "Option::is_none") )]
	pub fatca_form_tp: Option<Vec<FATCAForm1Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FATCASts", skip_serializing_if = "Option::is_none") )]
	pub fatca_sts: Option<Vec<FATCAStatus2>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FATCARptgDt", skip_serializing_if = "Option::is_none") )]
	pub fatca_rptg_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CRSFormTp", skip_serializing_if = "Option::is_none") )]
	pub crs_form_tp: Option<Vec<CRSForm1Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CRSSts", skip_serializing_if = "Option::is_none") )]
	pub crs_sts: Option<Vec<CRSStatus4>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CRSRptgDt", skip_serializing_if = "Option::is_none") )]
	pub crs_rptg_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrId", skip_serializing_if = "Option::is_none") )]
	pub othr_id: Option<Vec<GenericIdentification82>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxXmptn", skip_serializing_if = "Option::is_none") )]
	pub tax_xmptn: Option<TaxExemptionReason2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxRptg", skip_serializing_if = "Option::is_none") )]
	pub tax_rptg: Option<Vec<TaxReporting3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Lang", skip_serializing_if = "Option::is_none") )]
	pub lang: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MailTp", skip_serializing_if = "Option::is_none") )]
	pub mail_tp: Option<MailType1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtryAndResdtlSts", skip_serializing_if = "Option::is_none") )]
	pub ctry_and_resdtl_sts: Option<CountryAndResidentialStatusType2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MntryWlth", skip_serializing_if = "Option::is_none") )]
	pub mntry_wlth: Option<DateAndAmount1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EqtyVal", skip_serializing_if = "Option::is_none") )]
	pub eqty_val: Option<DateAndAmount1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WorkgCptl", skip_serializing_if = "Option::is_none") )]
	pub workg_cptl: Option<DateAndAmount1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CpnyLk", skip_serializing_if = "Option::is_none") )]
	pub cpny_lk: Option<CompanyLink1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ElctrncMlngSvcRef", skip_serializing_if = "Option::is_none") )]
	pub elctrnc_mlng_svc_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmryComAdr", skip_serializing_if = "Option::is_none") )]
	pub pmry_com_adr: Option<Vec<CommunicationAddress6>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ScndryComAdr", skip_serializing_if = "Option::is_none") )]
	pub scndry_com_adr: Option<Vec<CommunicationAddress6>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlRgltryInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_rgltry_inf: Option<RegulatoryInformation1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctgSts", skip_serializing_if = "Option::is_none") )]
	pub acctg_sts: Option<AccountingStatus1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<Vec<AdditiononalInformation13>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrlgPty", skip_serializing_if = "Option::is_none") )]
	pub ctrlg_pty: Option<bool>,
}

impl InvestmentAccountOwnershipInformation17 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pty.validate()?;
		if let Some(ref val) = self.mny_lndrg_chck { val.validate()? }
		if let Some(ref vec) = self.modfd_invstr_prfl_vldtn { for item in vec { item.validate()? } }
		if let Some(ref val) = self.ownrsh_bnfcry_rate { val.validate()? }
		if let Some(ref val) = self.clnt_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "clnt_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "clnt_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.mi_fid_clssfctn { val.validate()? }
		if let Some(ref vec) = self.ntfctn { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.fatca_form_tp { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.fatca_sts { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.crs_form_tp { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.crs_sts { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.othr_id { for item in vec { item.validate()? } }
		if let Some(ref val) = self.tax_xmptn { val.validate()? }
		if let Some(ref vec) = self.tax_rptg { for item in vec { item.validate()? } }
		if let Some(ref val) = self.mail_tp { val.validate()? }
		if let Some(ref val) = self.ctry_and_resdtl_sts { val.validate()? }
		if let Some(ref val) = self.mntry_wlth { val.validate()? }
		if let Some(ref val) = self.eqty_val { val.validate()? }
		if let Some(ref val) = self.workg_cptl { val.validate()? }
		if let Some(ref val) = self.cpny_lk { val.validate()? }
		if let Some(ref val) = self.elctrnc_mlng_svc_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "elctrnc_mlng_svc_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "elctrnc_mlng_svc_ref exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref vec) = self.pmry_com_adr { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.scndry_com_adr { for item in vec { item.validate()? } }
		if let Some(ref val) = self.addtl_rgltry_inf { val.validate()? }
		if let Some(ref val) = self.acctg_sts { val.validate()? }
		if let Some(ref vec) = self.addtl_inf { for item in vec { item.validate()? } }
		Ok(())
	}
}


// InvestmentFundMiFIDFee2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum InvestmentFundMiFIDFee2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "BORF") )]
	CodeBORF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DIS2") )]
	CodeDIS2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FES3") )]
	CodeFES3,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FEND") )]
	CodeFEND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FES2") )]
	CodeFES2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GOC1") )]
	CodeGOC1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GOCS") )]
	CodeGOCS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INCF") )]
	CodeINCF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INCS") )]
	CodeINCS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MNF1") )]
	CodeMNF1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MANS") )]
	CodeMANS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NET2") )]
	CodeNET2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NESF") )]
	CodeNESF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NETO") )]
	CodeNETO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NRAM") )]
	CodeNRAM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OOEA") )]
	CodeOOEA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OOSF") )]
	CodeOOSF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OOSS") )]
	CodeOOSS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BENS") )]
	CodeBENS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ENAC") )]
	CodeENAC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ENFX") )]
	CodeENFX,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EXAC") )]
	CodeEXAC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ENBX") )]
	CodeENBX,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BEND") )]
	CodeBEND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PENO") )]
	CodePENO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTES") )]
	CodeOTES,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OCAS") )]
	CodeOCAS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RPSS") )]
	CodeRPSS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TRS1") )]
	CodeTRS1,
}

impl InvestmentFundMiFIDFee2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// InvestmentFundOrder4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestmentFundOrder4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrdrRef", skip_serializing_if = "Option::is_none") )]
	pub ordr_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MstrRef", skip_serializing_if = "Option::is_none") )]
	pub mstr_ref: Option<String>,
}

impl InvestmentFundOrder4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ordr_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ordr_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "ordr_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.mstr_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mstr_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "mstr_ref exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// InvestmentFundPlanType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestmentFundPlanType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<InvestmentFundPlanType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification36>,
}

impl InvestmentFundPlanType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// InvestmentFundPlanType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum InvestmentFundPlanType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "INVP") )]
	CodeINVP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SWIP") )]
	CodeSWIP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WTHP") )]
	CodeWTHP,
}

impl InvestmentFundPlanType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// InvestmentFundRole6Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum InvestmentFundRole6Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CACO") )]
	CodeCACO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CONC") )]
	CodeCONC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CUST") )]
	CodeCUST,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DATP") )]
	CodeDATP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DIST") )]
	CodeDIST,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FACT") )]
	CodeFACT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FIAD") )]
	CodeFIAD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FIAG") )]
	CodeFIAG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FMCO") )]
	CodeFMCO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FNBR") )]
	CodeFNBR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FTAG") )]
	CodeFTAG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INTR") )]
	CodeINTR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INVE") )]
	CodeINVE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INVS") )]
	CodeINVS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PAYI") )]
	CodePAYI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REGI") )]
	CodeREGI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TRAG") )]
	CodeTRAG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TRAN") )]
	CodeTRAN,
}

impl InvestmentFundRole6Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// InvestmentFundRole7Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum InvestmentFundRole7Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CONC") )]
	CodeCONC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DIST") )]
	CodeDIST,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FMCO") )]
	CodeFMCO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INTR") )]
	CodeINTR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PAYI") )]
	CodePAYI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TRAG") )]
	CodeTRAG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CUST") )]
	CodeCUST,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CACO") )]
	CodeCACO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FACT") )]
	CodeFACT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INVE") )]
	CodeINVE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INVS") )]
	CodeINVS,
}

impl InvestmentFundRole7Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// InvestmentFundTransactionInType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestmentFundTransactionInType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<InvestmentFundTransactionInType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl InvestmentFundTransactionInType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// InvestmentFundTransactionInType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum InvestmentFundTransactionInType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "SUBS") )]
	CodeSUBS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SWII") )]
	CodeSWII,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INSP") )]
	CodeINSP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CROI") )]
	CodeCROI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RDIV") )]
	CodeRDIV,
}

impl InvestmentFundTransactionInType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// InvestmentFundTransactionOutType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestmentFundTransactionOutType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<InvestmentFundTransactionOutType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl InvestmentFundTransactionOutType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// InvestmentFundTransactionOutType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum InvestmentFundTransactionOutType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "REDM") )]
	CodeREDM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SWIO") )]
	CodeSWIO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INSP") )]
	CodeINSP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CROO") )]
	CodeCROO,
}

impl InvestmentFundTransactionOutType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// InvestmentFundTransactionType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum InvestmentFundTransactionType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ALLL") )]
	CodeALLL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SELL") )]
	CodeSELL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BUYI") )]
	CodeBUYI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SWIO") )]
	CodeSWIO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TRIN") )]
	CodeTRIN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TOUT") )]
	CodeTOUT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SUBS") )]
	CodeSUBS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REDM") )]
	CodeREDM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CDEP") )]
	CodeCDEP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CWIT") )]
	CodeCWIT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DIVP") )]
	CodeDIVP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CAEV") )]
	CodeCAEV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CROI") )]
	CodeCROI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CROO") )]
	CodeCROO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DIVI") )]
	CodeDIVI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INSP") )]
	CodeINSP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REAA") )]
	CodeREAA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RWPL") )]
	CodeRWPL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RDIV") )]
	CodeRDIV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SSPL") )]
	CodeSSPL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SUAA") )]
	CodeSUAA,
}

impl InvestmentFundTransactionType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// InvestmentNeed2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestmentNeed2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<InvestmentNeed2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl InvestmentNeed2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// InvestmentNeed2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum InvestmentNeed2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "NSPE") )]
	CodeNSPE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISLB") )]
	CodeISLB,
}

impl InvestmentNeed2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// InvestmentParty1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestmentParty1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prsn", skip_serializing_if = "Option::is_none") )]
	pub prsn: Option<PersonIdentification12>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Algo", skip_serializing_if = "Option::is_none") )]
	pub algo: Option<String>,
}

impl InvestmentParty1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.prsn { val.validate()? }
		if let Some(ref val) = self.algo {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "algo is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 50 {
				return Err(ValidationError::new(1002, "algo exceeds the maximum length of 50".to_string()));
			}
		}
		Ok(())
	}
}


// InvestmentPlan16 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestmentPlan16 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Frqcy") )]
	pub frqcy: Frequency20Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StartDt", skip_serializing_if = "Option::is_none") )]
	pub start_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndDt", skip_serializing_if = "Option::is_none") )]
	pub end_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Qty") )]
	pub qty: UnitsOrAmount1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GrssAmtInd", skip_serializing_if = "Option::is_none") )]
	pub grss_amt_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IncmPref", skip_serializing_if = "Option::is_none") )]
	pub incm_pref: Option<IncomePreference2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitlAmt", skip_serializing_if = "Option::is_none") )]
	pub initl_amt: Option<InitialAmount1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNbOfInstlmts", skip_serializing_if = "Option::is_none") )]
	pub ttl_nb_of_instlmts: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RndgDrctn", skip_serializing_if = "Option::is_none") )]
	pub rndg_drctn: Option<RoundingDirection1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctyDtls") )]
	pub scty_dtls: Vec<Repartition6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModfdCshSttlm", skip_serializing_if = "Option::is_none") )]
	pub modfd_csh_sttlm: Option<Vec<CashSettlement4>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctRef", skip_serializing_if = "Option::is_none") )]
	pub ctrct_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdCtrctRef", skip_serializing_if = "Option::is_none") )]
	pub rltd_ctrct_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PdctId", skip_serializing_if = "Option::is_none") )]
	pub pdct_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SLAChrgAndComssnRef", skip_serializing_if = "Option::is_none") )]
	pub sla_chrg_and_comssn_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InsrncCover", skip_serializing_if = "Option::is_none") )]
	pub insrnc_cover: Option<InsuranceType2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PlanSts", skip_serializing_if = "Option::is_none") )]
	pub plan_sts: Option<PlanStatus2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstlmtMgrRole", skip_serializing_if = "Option::is_none") )]
	pub instlmt_mgr_role: Option<PartyRole4Choice>,
}

impl InvestmentPlan16 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.frqcy.validate()?;
		self.qty.validate()?;
		if let Some(ref val) = self.incm_pref { val.validate()? }
		if let Some(ref val) = self.initl_amt { val.validate()? }
		if let Some(ref val) = self.rndg_drctn { val.validate()? }
		for item in &self.scty_dtls { item.validate()? }
		if let Some(ref vec) = self.modfd_csh_sttlm { for item in vec { item.validate()? } }
		if let Some(ref val) = self.ctrct_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ctrct_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "ctrct_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.rltd_ctrct_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rltd_ctrct_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "rltd_ctrct_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.pdct_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pdct_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "pdct_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.sla_chrg_and_comssn_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "sla_chrg_and_comssn_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "sla_chrg_and_comssn_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.insrnc_cover { val.validate()? }
		if let Some(ref val) = self.plan_sts { val.validate()? }
		if let Some(ref val) = self.instlmt_mgr_role { val.validate()? }
		Ok(())
	}
}


// InvestmentPlan17 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestmentPlan17 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Frqcy") )]
	pub frqcy: Frequency20Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StartDt", skip_serializing_if = "Option::is_none") )]
	pub start_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndDt", skip_serializing_if = "Option::is_none") )]
	pub end_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Qty") )]
	pub qty: UnitsOrAmount1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GrssAmtInd", skip_serializing_if = "Option::is_none") )]
	pub grss_amt_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IncmPref", skip_serializing_if = "Option::is_none") )]
	pub incm_pref: Option<IncomePreference2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitlAmt", skip_serializing_if = "Option::is_none") )]
	pub initl_amt: Option<InitialAmount1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNbOfInstlmts", skip_serializing_if = "Option::is_none") )]
	pub ttl_nb_of_instlmts: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RndgDrctn", skip_serializing_if = "Option::is_none") )]
	pub rndg_drctn: Option<RoundingDirection1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctyDtls") )]
	pub scty_dtls: Vec<Repartition6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshSttlm", skip_serializing_if = "Option::is_none") )]
	pub csh_sttlm: Option<Vec<CashSettlement3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctRef", skip_serializing_if = "Option::is_none") )]
	pub ctrct_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdCtrctRef", skip_serializing_if = "Option::is_none") )]
	pub rltd_ctrct_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PdctId", skip_serializing_if = "Option::is_none") )]
	pub pdct_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SLAChrgAndComssnRef", skip_serializing_if = "Option::is_none") )]
	pub sla_chrg_and_comssn_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InsrncCover", skip_serializing_if = "Option::is_none") )]
	pub insrnc_cover: Option<InsuranceType2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PlanSts", skip_serializing_if = "Option::is_none") )]
	pub plan_sts: Option<PlanStatus2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstlmtMgrRole", skip_serializing_if = "Option::is_none") )]
	pub instlmt_mgr_role: Option<PartyRole4Choice>,
}

impl InvestmentPlan17 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.frqcy.validate()?;
		self.qty.validate()?;
		if let Some(ref val) = self.incm_pref { val.validate()? }
		if let Some(ref val) = self.initl_amt { val.validate()? }
		if let Some(ref val) = self.rndg_drctn { val.validate()? }
		for item in &self.scty_dtls { item.validate()? }
		if let Some(ref vec) = self.csh_sttlm { for item in vec { item.validate()? } }
		if let Some(ref val) = self.ctrct_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ctrct_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "ctrct_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.rltd_ctrct_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rltd_ctrct_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "rltd_ctrct_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.pdct_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pdct_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "pdct_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.sla_chrg_and_comssn_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "sla_chrg_and_comssn_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "sla_chrg_and_comssn_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.insrnc_cover { val.validate()? }
		if let Some(ref val) = self.plan_sts { val.validate()? }
		if let Some(ref val) = self.instlmt_mgr_role { val.validate()? }
		Ok(())
	}
}


// InvestmentPlanCharacteristics1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestmentPlanCharacteristics1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PlanTp") )]
	pub plan_tp: InvestmentFundPlanType1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Frqcy", skip_serializing_if = "Option::is_none") )]
	pub frqcy: Option<Frequency20Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNbOfInstlmts", skip_serializing_if = "Option::is_none") )]
	pub ttl_nb_of_instlmts: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Qty", skip_serializing_if = "Option::is_none") )]
	pub qty: Option<UnitsOrAmount1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PlanConttn", skip_serializing_if = "Option::is_none") )]
	pub plan_conttn: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlSbcpt", skip_serializing_if = "Option::is_none") )]
	pub addtl_sbcpt: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlSbcptFctn", skip_serializing_if = "Option::is_none") )]
	pub addtl_sbcpt_fctn: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<Vec<AdditionalInformation15>>,
}

impl InvestmentPlanCharacteristics1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.plan_tp.validate()?;
		if let Some(ref val) = self.frqcy { val.validate()? }
		if let Some(ref val) = self.qty { val.validate()? }
		if let Some(ref vec) = self.addtl_inf { for item in vec { item.validate()? } }
		Ok(())
	}
}


// InvestmentRestrictions3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestmentRestrictions3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MinInitlSbcptAmt", skip_serializing_if = "Option::is_none") )]
	pub min_initl_sbcpt_amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MinInitlSbcptUnits", skip_serializing_if = "Option::is_none") )]
	pub min_initl_sbcpt_units: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MinSbsqntSbcptAmt", skip_serializing_if = "Option::is_none") )]
	pub min_sbsqnt_sbcpt_amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MinSbsqntSbcptUnits", skip_serializing_if = "Option::is_none") )]
	pub min_sbsqnt_sbcpt_units: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MaxRedAmt", skip_serializing_if = "Option::is_none") )]
	pub max_red_amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MaxRedUnits", skip_serializing_if = "Option::is_none") )]
	pub max_red_units: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MinRedPctg", skip_serializing_if = "Option::is_none") )]
	pub min_red_pctg: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrRedRstrctns", skip_serializing_if = "Option::is_none") )]
	pub othr_red_rstrctns: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MinSwtchSbcptAmt", skip_serializing_if = "Option::is_none") )]
	pub min_swtch_sbcpt_amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MinSwtchSbcptUnits", skip_serializing_if = "Option::is_none") )]
	pub min_swtch_sbcpt_units: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MaxSwtchRedAmt", skip_serializing_if = "Option::is_none") )]
	pub max_swtch_red_amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MaxSwtchRedUnits", skip_serializing_if = "Option::is_none") )]
	pub max_swtch_red_units: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrSwtchRstrctns", skip_serializing_if = "Option::is_none") )]
	pub othr_swtch_rstrctns: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MinHldgAmt", skip_serializing_if = "Option::is_none") )]
	pub min_hldg_amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MinHldgUnits", skip_serializing_if = "Option::is_none") )]
	pub min_hldg_units: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MinHldgPrd", skip_serializing_if = "Option::is_none") )]
	pub min_hldg_prd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HldgTrfbl", skip_serializing_if = "Option::is_none") )]
	pub hldg_trfbl: Option<HoldingTransferable1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<Vec<AdditionalInformation15>>,
}

impl InvestmentRestrictions3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.min_initl_sbcpt_amt { val.validate()? }
		if let Some(ref val) = self.min_sbsqnt_sbcpt_amt { val.validate()? }
		if let Some(ref val) = self.max_red_amt { val.validate()? }
		if let Some(ref val) = self.othr_red_rstrctns {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "othr_red_rstrctns is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "othr_red_rstrctns exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.min_swtch_sbcpt_amt { val.validate()? }
		if let Some(ref val) = self.max_swtch_red_amt { val.validate()? }
		if let Some(ref val) = self.othr_swtch_rstrctns {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "othr_swtch_rstrctns is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "othr_swtch_rstrctns exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.min_hldg_amt { val.validate()? }
		if let Some(ref val) = self.min_hldg_prd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "min_hldg_prd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "min_hldg_prd exceeds the maximum length of 70".to_string()));
			}
		}
		if let Some(ref val) = self.hldg_trfbl { val.validate()? }
		if let Some(ref vec) = self.addtl_inf { for item in vec { item.validate()? } }
		Ok(())
	}
}


// InvestorKnowledge1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestorKnowledge1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BsicInvstr", skip_serializing_if = "Option::is_none") )]
	pub bsic_invstr: Option<TargetMarket1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InfrmdInvstr", skip_serializing_if = "Option::is_none") )]
	pub infrmd_invstr: Option<TargetMarket1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AdvncdInvstr", skip_serializing_if = "Option::is_none") )]
	pub advncd_invstr: Option<TargetMarket1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExprtInvstrDE", skip_serializing_if = "Option::is_none") )]
	pub exprt_invstr_de: Option<TargetMarket1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<Vec<OtherTargetMarketInvestorKnowledge1>>,
}

impl InvestorKnowledge1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.bsic_invstr { val.validate()? }
		if let Some(ref val) = self.infrmd_invstr { val.validate()? }
		if let Some(ref val) = self.advncd_invstr { val.validate()? }
		if let Some(ref val) = self.exprt_invstr_de { val.validate()? }
		if let Some(ref vec) = self.othr { for item in vec { item.validate()? } }
		Ok(())
	}
}


// InvestorProfile2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestorProfile2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<ProfileType1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts", skip_serializing_if = "Option::is_none") )]
	pub sts: Option<InvestorProfileStatus1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Trsr", skip_serializing_if = "Option::is_none") )]
	pub trsr: Option<TreasuryProfile1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HghFrqcyTradg", skip_serializing_if = "Option::is_none") )]
	pub hgh_frqcy_tradg: Option<HighFrequencyTradingProfile1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktMakr", skip_serializing_if = "Option::is_none") )]
	pub mkt_makr: Option<MarketMakerProfile2>,
}

impl InvestorProfile2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.sts { val.validate()? }
		if let Some(ref val) = self.trsr { val.validate()? }
		if let Some(ref val) = self.hgh_frqcy_tradg { val.validate()? }
		if let Some(ref val) = self.mkt_makr { val.validate()? }
		Ok(())
	}
}


// InvestorProfileStatus1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestorProfileStatus1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<InvestorProfileStatus1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl InvestorProfileStatus1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// InvestorProfileStatus1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum InvestorProfileStatus1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "DISA") )]
	CodeDISA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DISG") )]
	CodeDISG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ENAB") )]
	CodeENAB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ENBG") )]
	CodeENBG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ADMI") )]
	CodeADMI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ANLY") )]
	CodeANLY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NAPP") )]
	CodeNAPP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PSUS") )]
	CodePSUS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PEND") )]
	CodePEND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SUPS") )]
	CodeSUPS,
}

impl InvestorProfileStatus1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// InvestorRequirements4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestorRequirements4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RtrPrflPrsrvtn", skip_serializing_if = "Option::is_none") )]
	pub rtr_prfl_prsrvtn: Option<TargetMarket1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RtrPrflGrwth", skip_serializing_if = "Option::is_none") )]
	pub rtr_prfl_grwth: Option<TargetMarket1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RtrPrflIncm", skip_serializing_if = "Option::is_none") )]
	pub rtr_prfl_incm: Option<TargetMarket1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RtrPrflHdgg", skip_serializing_if = "Option::is_none") )]
	pub rtr_prfl_hdgg: Option<TargetMarket1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OptnOrLvrgdRtrPrfl", skip_serializing_if = "Option::is_none") )]
	pub optn_or_lvrgd_rtr_prfl: Option<TargetMarket1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RtrPrflPnsnSchmeDE", skip_serializing_if = "Option::is_none") )]
	pub rtr_prfl_pnsn_schme_de: Option<TargetMarket1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MinHldgPrd", skip_serializing_if = "Option::is_none") )]
	pub min_hldg_prd: Option<TimeHorizon2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SstnbltyPrefs", skip_serializing_if = "Option::is_none") )]
	pub sstnblty_prefs: Option<SustainabilityPreferences2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrSpcfcInvstmtNeed", skip_serializing_if = "Option::is_none") )]
	pub othr_spcfc_invstmt_need: Option<InvestmentNeed2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<Vec<OtherInvestmentNeed1>>,
}

impl InvestorRequirements4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rtr_prfl_prsrvtn { val.validate()? }
		if let Some(ref val) = self.rtr_prfl_grwth { val.validate()? }
		if let Some(ref val) = self.rtr_prfl_incm { val.validate()? }
		if let Some(ref val) = self.rtr_prfl_hdgg { val.validate()? }
		if let Some(ref val) = self.optn_or_lvrgd_rtr_prfl { val.validate()? }
		if let Some(ref val) = self.rtr_prfl_pnsn_schme_de { val.validate()? }
		if let Some(ref val) = self.min_hldg_prd { val.validate()? }
		if let Some(ref val) = self.sstnblty_prefs { val.validate()? }
		if let Some(ref val) = self.othr_spcfc_invstmt_need { val.validate()? }
		if let Some(ref vec) = self.othr { for item in vec { item.validate()? } }
		Ok(())
	}
}


// InvestorRestrictionType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum InvestorRestrictionType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "LERE") )]
	CodeLERE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CITI") )]
	CodeCITI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INDV") )]
	CodeINDV,
}

impl InvestorRestrictionType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// InvestorRestrictionType3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestorRestrictionType3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<InvestorRestrictionType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl InvestorRestrictionType3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// InvestorType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum InvestorType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "RETL") )]
	CodeRETL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PROF") )]
	CodePROF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "STAF") )]
	CodeSTAF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PPER") )]
	CodePPER,
}

impl InvestorType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// InvestorType2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestorType2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstrTpRtl", skip_serializing_if = "Option::is_none") )]
	pub invstr_tp_rtl: Option<TargetMarket1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstrTpPrfssnl", skip_serializing_if = "Option::is_none") )]
	pub invstr_tp_prfssnl: Option<TargetMarket5Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstrTpElgblCtrPty", skip_serializing_if = "Option::is_none") )]
	pub invstr_tp_elgbl_ctr_pty: Option<TargetMarket3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<Vec<OtherTargetMarketInvestor1>>,
}

impl InvestorType2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.invstr_tp_rtl { val.validate()? }
		if let Some(ref val) = self.invstr_tp_prfssnl { val.validate()? }
		if let Some(ref val) = self.invstr_tp_elgbl_ctr_pty { val.validate()? }
		if let Some(ref vec) = self.othr { for item in vec { item.validate()? } }
		Ok(())
	}
}


// InvestorType2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum InvestorType2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "BOT3") )]
	CodeBOT3,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EPRO") )]
	CodeEPRO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRF2") )]
	CodePRF2,
}

impl InvestorType2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// InvestorType3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvestorType3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<InvestorType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl InvestorType3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// InvestorType3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum InvestorType3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "RETL") )]
	CodeRETL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRF2") )]
	CodePRF2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NEI1") )]
	CodeNEI1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BOT2") )]
	CodeBOT2,
}

impl InvestorType3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// InvestorType4Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum InvestorType4Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "BOT3") )]
	CodeBOT3,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NPRF") )]
	CodeNPRF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRF3") )]
	CodePRF3,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRF4") )]
	CodePRF4,
}

impl InvestorType4Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// InvoiceTaxReportTransactionStatus1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvoiceTaxReportTransactionStatus1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxRptId") )]
	pub tax_rpt_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts") )]
	pub sts: TaxReportingStatus2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldtnRule", skip_serializing_if = "Option::is_none") )]
	pub vldtn_rule: Option<Vec<GenericValidationRuleIdentification1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl InvoiceTaxReportTransactionStatus1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.tax_rpt_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "tax_rpt_id is shorter than the minimum length of 1".to_string()));
		}
		if self.tax_rpt_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "tax_rpt_id exceeds the maximum length of 35".to_string()));
		}
		self.sts.validate()?;
		if let Some(ref vec) = self.vldtn_rule { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// InvoiceTaxStatusReportHeader1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct InvoiceTaxStatusReportHeader1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxAuthrty", skip_serializing_if = "Option::is_none") )]
	pub tax_authrty: Option<TaxOrganisationIdentification1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: MessageIdentification1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMsgId") )]
	pub orgnl_msg_id: MessageIdentification1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptSts") )]
	pub rpt_sts: TaxReportingStatus1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldtnRule", skip_serializing_if = "Option::is_none") )]
	pub vldtn_rule: Option<Vec<GenericValidationRuleIdentification1>>,
}

impl InvoiceTaxStatusReportHeader1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tax_authrty { val.validate()? }
		self.msg_id.validate()?;
		self.orgnl_msg_id.validate()?;
		self.rpt_sts.validate()?;
		if let Some(ref vec) = self.vldtn_rule { for item in vec { item.validate()? } }
		Ok(())
	}
}


// Issuance5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Issuance5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "IssePlc", skip_serializing_if = "Option::is_none") )]
	pub isse_plc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtryOfIsse", skip_serializing_if = "Option::is_none") )]
	pub ctry_of_isse: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IsseDt", skip_serializing_if = "Option::is_none") )]
	pub isse_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AnncmntDt", skip_serializing_if = "Option::is_none") )]
	pub anncmnt_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISINVldFr", skip_serializing_if = "Option::is_none") )]
	pub isin_vld_fr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IssrOrg", skip_serializing_if = "Option::is_none") )]
	pub issr_org: Option<Organisation38>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IsseNmnlAmt", skip_serializing_if = "Option::is_none") )]
	pub isse_nmnl_amt: Option<FinancialInstrumentQuantity1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FullIssdAmt", skip_serializing_if = "Option::is_none") )]
	pub full_issd_amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IsseSz", skip_serializing_if = "Option::is_none") )]
	pub isse_sz: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IssePric", skip_serializing_if = "Option::is_none") )]
	pub isse_pric: Option<PriceValue1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IssncDstrbtn", skip_serializing_if = "Option::is_none") )]
	pub issnc_dstrbtn: Option<SecuritiesTransactionType31Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GovngLaw", skip_serializing_if = "Option::is_none") )]
	pub govng_law: Option<Vec<Jurisdiction1>>,
}

impl Issuance5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.isse_plc {
			let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "isse_plc does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.ctry_of_isse {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry_of_isse does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.issr_org { val.validate()? }
		if let Some(ref val) = self.isse_nmnl_amt { val.validate()? }
		if let Some(ref val) = self.full_issd_amt { val.validate()? }
		if let Some(ref val) = self.isse_pric { val.validate()? }
		if let Some(ref val) = self.issnc_dstrbtn { val.validate()? }
		if let Some(ref vec) = self.govng_law { for item in vec { item.validate()? } }
		Ok(())
	}
}


// Issuance6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Issuance6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "IssePlc", skip_serializing_if = "Option::is_none") )]
	pub isse_plc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtryOfIsse", skip_serializing_if = "Option::is_none") )]
	pub ctry_of_isse: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IsseDt", skip_serializing_if = "Option::is_none") )]
	pub isse_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AnncmntDt", skip_serializing_if = "Option::is_none") )]
	pub anncmnt_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IssrOrg", skip_serializing_if = "Option::is_none") )]
	pub issr_org: Option<Organisation38>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IsseNmnlAmt", skip_serializing_if = "Option::is_none") )]
	pub isse_nmnl_amt: Option<FinancialInstrumentQuantity1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FullIssdAmt", skip_serializing_if = "Option::is_none") )]
	pub full_issd_amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IsseSz", skip_serializing_if = "Option::is_none") )]
	pub isse_sz: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IssePric", skip_serializing_if = "Option::is_none") )]
	pub isse_pric: Option<PriceValue1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IssncDstrbtn", skip_serializing_if = "Option::is_none") )]
	pub issnc_dstrbtn: Option<SecuritiesTransactionType31Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GovngLaw", skip_serializing_if = "Option::is_none") )]
	pub govng_law: Option<Vec<Jurisdiction1>>,
}

impl Issuance6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.isse_plc {
			let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "isse_plc does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.ctry_of_isse {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry_of_isse does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.issr_org { val.validate()? }
		if let Some(ref val) = self.isse_nmnl_amt { val.validate()? }
		if let Some(ref val) = self.full_issd_amt { val.validate()? }
		if let Some(ref val) = self.isse_pric { val.validate()? }
		if let Some(ref val) = self.issnc_dstrbtn { val.validate()? }
		if let Some(ref vec) = self.govng_law { for item in vec { item.validate()? } }
		Ok(())
	}
}


// IssuanceAccount2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IssuanceAccount2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "IssncAcct") )]
	pub issnc_acct: SecuritiesAccount19,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmryAcctInd") )]
	pub pmry_acct_ind: bool,
}

impl IssuanceAccount2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.issnc_acct.validate()?;
		Ok(())
	}
}


// IssuerCSDIdentification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IssuerCSDIdentification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "LEI", skip_serializing_if = "Option::is_none") )]
	pub lei: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrstTwoCharsInstrmId") )]
	pub frst_two_chars_instrm_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctry", skip_serializing_if = "Option::is_none") )]
	pub ctry: Option<String>,
}

impl IssuerCSDIdentification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.lei {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "lei does not match the required pattern".to_string()));
			}
		}
		let pattern = Regex::new("[A-Z]{2}").unwrap();
		if !pattern.is_match(&self.frst_two_chars_instrm_id) {
			return Err(ValidationError::new(1005, "frst_two_chars_instrm_id does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.ctry {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// IssuerCSDReport1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IssuerCSDReport1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: IssuerCSDIdentification1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OvrllTtl") )]
	pub ovrll_ttl: InternalisationData1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrm") )]
	pub fin_instrm: SettlementInternaliserFinancialInstrument1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxTp") )]
	pub tx_tp: SettlementInternaliserTransactionType1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClntTp") )]
	pub clnt_tp: SettlementInternaliserClientType1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlCshTrf") )]
	pub ttl_csh_trf: InternalisationData1,
}

impl IssuerCSDReport1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.id.validate()?;
		self.ovrll_ttl.validate()?;
		self.fin_instrm.validate()?;
		self.tx_tp.validate()?;
		self.clnt_tp.validate()?;
		self.ttl_csh_trf.validate()?;
		Ok(())
	}
}


// IssuerJurisdiction1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct IssuerJurisdiction1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtryCd", skip_serializing_if = "Option::is_none") )]
	pub ctry_cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<String>,
}

impl IssuerJurisdiction1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ctry_cd {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry_cd does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.othr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "othr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "othr exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// Jurisdiction1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Jurisdiction1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctry", skip_serializing_if = "Option::is_none") )]
	pub ctry: Option<String>,
}

impl Jurisdiction1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "id exceeds the maximum length of 70".to_string()));
			}
		}
		if let Some(ref val) = self.ctry {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// KYCCheckType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct KYCCheckType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<KnowYourCustomerCheckType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl KYCCheckType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// KnowYourCustomerCheckType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum KnowYourCustomerCheckType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ENHA") )]
	CodeENHA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ORDN") )]
	CodeORDN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SIMP") )]
	CodeSIMP,
}

impl KnowYourCustomerCheckType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// LaxPayload ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LaxPayload {
}

impl LaxPayload {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// LegalMandate1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LegalMandate1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prgrph") )]
	pub prgrph: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dsclmr", skip_serializing_if = "Option::is_none") )]
	pub dsclmr: Option<String>,
}

impl LegalMandate1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.prgrph.chars().count() < 1 {
			return Err(ValidationError::new(1001, "prgrph is shorter than the minimum length of 1".to_string()));
		}
		if self.prgrph.chars().count() > 35 {
			return Err(ValidationError::new(1002, "prgrph exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.dsclmr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "dsclmr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "dsclmr exceeds the maximum length of 350".to_string()));
			}
		}
		Ok(())
	}
}


// LegalOrganisation1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LegalOrganisation1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
}

impl LegalOrganisation1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// LegalOrganisation2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LegalOrganisation2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EstblishmtDt", skip_serializing_if = "Option::is_none") )]
	pub estblishmt_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegnDt", skip_serializing_if = "Option::is_none") )]
	pub regn_dt: Option<String>,
}

impl LegalOrganisation2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// LegalPersonIdentification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LegalPersonIdentification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: OrganisationIdentification15Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctry", skip_serializing_if = "Option::is_none") )]
	pub ctry: Option<String>,
}

impl LegalPersonIdentification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.id.validate()?;
		if let Some(ref val) = self.ctry {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// LegalRestrictions1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum LegalRestrictions1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "USLE") )]
	CodeUSLE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NORE") )]
	CodeNORE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REST") )]
	CodeREST,
}

impl LegalRestrictions1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// LegalRestrictions2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum LegalRestrictions2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "JURO") )]
	CodeJURO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PPLA") )]
	CodePPLA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACRI") )]
	CodeACRI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MARG") )]
	CodeMARG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRIV") )]
	CodePRIV,
}

impl LegalRestrictions2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// LegalRestrictions4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LegalRestrictions4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<LegalRestrictions1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl LegalRestrictions4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// LegalRestrictions5Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LegalRestrictions5Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<LegalRestrictions2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl LegalRestrictions5Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// LetterIntent1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LetterIntent1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "LttrInttRef") )]
	pub lttr_intt_ref: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<ActiveCurrencyAnd13DecimalAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StartDt", skip_serializing_if = "Option::is_none") )]
	pub start_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndDt", skip_serializing_if = "Option::is_none") )]
	pub end_dt: Option<String>,
}

impl LetterIntent1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.lttr_intt_ref.chars().count() < 1 {
			return Err(ValidationError::new(1001, "lttr_intt_ref is shorter than the minimum length of 1".to_string()));
		}
		if self.lttr_intt_ref.chars().count() > 35 {
			return Err(ValidationError::new(1002, "lttr_intt_ref exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.amt { val.validate()? }
		Ok(())
	}
}


// LevelOfControl1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LevelOfControl1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<LevelOfControl1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl LevelOfControl1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// LevelOfControl1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum LevelOfControl1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "TRAN") )]
	CodeTRAN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VIEW") )]
	CodeVIEW,
}

impl LevelOfControl1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Liability1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Liability1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<Liability1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl Liability1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// Liability1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum Liability1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "INVE") )]
	CodeINVE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BROK") )]
	CodeBROK,
}

impl Liability1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Limit10 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Limit10 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: Amount2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbtInd", skip_serializing_if = "Option::is_none") )]
	pub cdt_dbt_ind: Option<CreditDebitCode>,
}

impl Limit10 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.amt.validate()?;
		if let Some(ref val) = self.cdt_dbt_ind { val.validate()? }
		Ok(())
	}
}


// Limit2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Limit2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveOrHistoricCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbtInd") )]
	pub cdt_dbt_ind: FloorLimitType1Code,
}

impl Limit2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.amt.validate()?;
		self.cdt_dbt_ind.validate()?;
		Ok(())
	}
}


// Limit5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Limit5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: Amount2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbtInd") )]
	pub cdt_dbt_ind: CreditDebitCode,
}

impl Limit5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.amt.validate()?;
		self.cdt_dbt_ind.validate()?;
		Ok(())
	}
}


// Limit7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Limit7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: Amount2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbtInd", skip_serializing_if = "Option::is_none") )]
	pub cdt_dbt_ind: Option<CreditDebitCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts", skip_serializing_if = "Option::is_none") )]
	pub sts: Option<LimitStatus1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StartDtTm", skip_serializing_if = "Option::is_none") )]
	pub start_dt_tm: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UsdAmt", skip_serializing_if = "Option::is_none") )]
	pub usd_amt: Option<Amount2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UsdAmtCdtDbtInd", skip_serializing_if = "Option::is_none") )]
	pub usd_amt_cdt_dbt_ind: Option<CreditDebitCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UsdPctg", skip_serializing_if = "Option::is_none") )]
	pub usd_pctg: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RmngAmt", skip_serializing_if = "Option::is_none") )]
	pub rmng_amt: Option<Amount2Choice>,
}

impl Limit7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.amt.validate()?;
		if let Some(ref val) = self.cdt_dbt_ind { val.validate()? }
		if let Some(ref val) = self.sts { val.validate()? }
		if let Some(ref val) = self.start_dt_tm { val.validate()? }
		if let Some(ref val) = self.usd_amt { val.validate()? }
		if let Some(ref val) = self.usd_amt_cdt_dbt_ind { val.validate()? }
		if let Some(ref val) = self.rmng_amt { val.validate()? }
		Ok(())
	}
}


// Limit8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Limit8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "StartDtTm", skip_serializing_if = "Option::is_none") )]
	pub start_dt_tm: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: Amount2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbtInd", skip_serializing_if = "Option::is_none") )]
	pub cdt_dbt_ind: Option<CreditDebitCode>,
}

impl Limit8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.start_dt_tm { val.validate()? }
		self.amt.validate()?;
		if let Some(ref val) = self.cdt_dbt_ind { val.validate()? }
		Ok(())
	}
}


// LimitCriteria7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LimitCriteria7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NewQryNm", skip_serializing_if = "Option::is_none") )]
	pub new_qry_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SchCrit", skip_serializing_if = "Option::is_none") )]
	pub sch_crit: Option<Vec<LimitSearchCriteria7>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RtrCrit", skip_serializing_if = "Option::is_none") )]
	pub rtr_crit: Option<LimitReturnCriteria2>,
}

impl LimitCriteria7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.new_qry_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "new_qry_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "new_qry_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref vec) = self.sch_crit { for item in vec { item.validate()? } }
		if let Some(ref val) = self.rtr_crit { val.validate()? }
		Ok(())
	}
}


// LimitCriteria7Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LimitCriteria7Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "QryNm", skip_serializing_if = "Option::is_none") )]
	pub qry_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NewCrit", skip_serializing_if = "Option::is_none") )]
	pub new_crit: Option<LimitCriteria7>,
}

impl LimitCriteria7Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.qry_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "qry_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "qry_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.new_crit { val.validate()? }
		Ok(())
	}
}


// LimitIdentification3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LimitIdentification3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cur", skip_serializing_if = "Option::is_none") )]
	pub cur: Option<LimitIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dflt", skip_serializing_if = "Option::is_none") )]
	pub dflt: Option<LimitIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AllCur", skip_serializing_if = "Option::is_none") )]
	pub all_cur: Option<LimitIdentification9>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AllDflt", skip_serializing_if = "Option::is_none") )]
	pub all_dflt: Option<LimitIdentification9>,
}

impl LimitIdentification3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cur { val.validate()? }
		if let Some(ref val) = self.dflt { val.validate()? }
		if let Some(ref val) = self.all_cur { val.validate()? }
		if let Some(ref val) = self.all_dflt { val.validate()? }
		Ok(())
	}
}


// LimitIdentification8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LimitIdentification8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SysId", skip_serializing_if = "Option::is_none") )]
	pub sys_id: Option<SystemIdentification2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BilLmtCtrPtyId", skip_serializing_if = "Option::is_none") )]
	pub bil_lmt_ctr_pty_id: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: LimitType1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctOwnr", skip_serializing_if = "Option::is_none") )]
	pub acct_ownr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctId", skip_serializing_if = "Option::is_none") )]
	pub acct_id: Option<AccountIdentification4Choice>,
}

impl LimitIdentification8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.sys_id { val.validate()? }
		if let Some(ref val) = self.bil_lmt_ctr_pty_id { val.validate()? }
		self.tp.validate()?;
		if let Some(ref val) = self.acct_ownr { val.validate()? }
		if let Some(ref val) = self.acct_id { val.validate()? }
		Ok(())
	}
}


// LimitIdentification9 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LimitIdentification9 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SysId", skip_serializing_if = "Option::is_none") )]
	pub sys_id: Option<SystemIdentification2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: LimitType1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctOwnr", skip_serializing_if = "Option::is_none") )]
	pub acct_ownr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctId", skip_serializing_if = "Option::is_none") )]
	pub acct_id: Option<AccountIdentification4Choice>,
}

impl LimitIdentification9 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.sys_id { val.validate()? }
		self.tp.validate()?;
		if let Some(ref val) = self.acct_ownr { val.validate()? }
		if let Some(ref val) = self.acct_id { val.validate()? }
		Ok(())
	}
}


// LimitOrError4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LimitOrError4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Lmt", skip_serializing_if = "Option::is_none") )]
	pub lmt: Option<Limit7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizErr", skip_serializing_if = "Option::is_none") )]
	pub biz_err: Option<Vec<ErrorHandling5>>,
}

impl LimitOrError4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.lmt { val.validate()? }
		if let Some(ref vec) = self.biz_err { for item in vec { item.validate()? } }
		Ok(())
	}
}


// LimitQuery5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LimitQuery5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "QryTp", skip_serializing_if = "Option::is_none") )]
	pub qry_tp: Option<QueryType2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LmtCrit", skip_serializing_if = "Option::is_none") )]
	pub lmt_crit: Option<LimitCriteria7Choice>,
}

impl LimitQuery5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.qry_tp { val.validate()? }
		if let Some(ref val) = self.lmt_crit { val.validate()? }
		Ok(())
	}
}


// LimitReport8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LimitReport8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "LmtId") )]
	pub lmt_id: LimitIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LmtOrErr") )]
	pub lmt_or_err: LimitOrError4Choice,
}

impl LimitReport8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.lmt_id.validate()?;
		self.lmt_or_err.validate()?;
		Ok(())
	}
}


// LimitReportOrError5Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LimitReportOrError5Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizRpt", skip_serializing_if = "Option::is_none") )]
	pub biz_rpt: Option<Limits8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OprlErr", skip_serializing_if = "Option::is_none") )]
	pub oprl_err: Option<Vec<ErrorHandling5>>,
}

impl LimitReportOrError5Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.biz_rpt { val.validate()? }
		if let Some(ref vec) = self.oprl_err { for item in vec { item.validate()? } }
		Ok(())
	}
}


// LimitReturnCriteria2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LimitReturnCriteria2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "StartDtTmInd", skip_serializing_if = "Option::is_none") )]
	pub start_dt_tm_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsInd", skip_serializing_if = "Option::is_none") )]
	pub sts_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UsdAmtInd", skip_serializing_if = "Option::is_none") )]
	pub usd_amt_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UsdPctgInd", skip_serializing_if = "Option::is_none") )]
	pub usd_pctg_ind: Option<bool>,
}

impl LimitReturnCriteria2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// LimitSearchCriteria7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LimitSearchCriteria7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SysId", skip_serializing_if = "Option::is_none") )]
	pub sys_id: Option<SystemIdentification2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BilLmtCtrPtyId", skip_serializing_if = "Option::is_none") )]
	pub bil_lmt_ctr_pty_id: Option<Vec<BranchAndFinancialInstitutionIdentification8>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DfltLmtTp", skip_serializing_if = "Option::is_none") )]
	pub dflt_lmt_tp: Option<Vec<LimitType1Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CurLmtTp", skip_serializing_if = "Option::is_none") )]
	pub cur_lmt_tp: Option<Vec<LimitType1Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctOwnr", skip_serializing_if = "Option::is_none") )]
	pub acct_ownr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctId", skip_serializing_if = "Option::is_none") )]
	pub acct_id: Option<AccountIdentification4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UsdAmt", skip_serializing_if = "Option::is_none") )]
	pub usd_amt: Option<ActiveAmountRange3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UsdPctg", skip_serializing_if = "Option::is_none") )]
	pub usd_pctg: Option<PercentageRange1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LmtCcy", skip_serializing_if = "Option::is_none") )]
	pub lmt_ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LmtAmt", skip_serializing_if = "Option::is_none") )]
	pub lmt_amt: Option<ActiveAmountRange3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LmtVldAsOfDt", skip_serializing_if = "Option::is_none") )]
	pub lmt_vld_as_of_dt: Option<DateAndPeriod2Choice>,
}

impl LimitSearchCriteria7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.sys_id { val.validate()? }
		if let Some(ref vec) = self.bil_lmt_ctr_pty_id { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.dflt_lmt_tp { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.cur_lmt_tp { for item in vec { item.validate()? } }
		if let Some(ref val) = self.acct_ownr { val.validate()? }
		if let Some(ref val) = self.acct_id { val.validate()? }
		if let Some(ref val) = self.usd_amt { val.validate()? }
		if let Some(ref val) = self.usd_pctg { val.validate()? }
		if let Some(ref val) = self.lmt_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "lmt_ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.lmt_amt { val.validate()? }
		if let Some(ref val) = self.lmt_vld_as_of_dt { val.validate()? }
		Ok(())
	}
}


// LimitStatus1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum LimitStatus1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ENAB") )]
	CodeENAB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DISA") )]
	CodeDISA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DELD") )]
	CodeDELD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REQD") )]
	CodeREQD,
}

impl LimitStatus1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// LimitStructure3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LimitStructure3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CurLmtId", skip_serializing_if = "Option::is_none") )]
	pub cur_lmt_id: Option<LimitIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AllCurLmts", skip_serializing_if = "Option::is_none") )]
	pub all_cur_lmts: Option<LimitIdentification9>,
}

impl LimitStructure3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cur_lmt_id { val.validate()? }
		if let Some(ref val) = self.all_cur_lmts { val.validate()? }
		Ok(())
	}
}


// LimitStructure5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LimitStructure5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "LmtId") )]
	pub lmt_id: LimitIdentification3Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NewLmtValSet") )]
	pub new_lmt_val_set: Limit8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OdLmtValSet", skip_serializing_if = "Option::is_none") )]
	pub od_lmt_val_set: Option<Limit10>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LmtValAmdmnt", skip_serializing_if = "Option::is_none") )]
	pub lmt_val_amdmnt: Option<Amount4Choice>,
}

impl LimitStructure5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.lmt_id.validate()?;
		self.new_lmt_val_set.validate()?;
		if let Some(ref val) = self.od_lmt_val_set { val.validate()? }
		if let Some(ref val) = self.lmt_val_amdmnt { val.validate()? }
		Ok(())
	}
}


// LimitStructure6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LimitStructure6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "LmtId") )]
	pub lmt_id: LimitIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StartDtTm", skip_serializing_if = "Option::is_none") )]
	pub start_dt_tm: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: Amount2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbtInd", skip_serializing_if = "Option::is_none") )]
	pub cdt_dbt_ind: Option<CreditDebitCode>,
}

impl LimitStructure6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.lmt_id.validate()?;
		if let Some(ref val) = self.start_dt_tm { val.validate()? }
		self.amt.validate()?;
		if let Some(ref val) = self.cdt_dbt_ind { val.validate()? }
		Ok(())
	}
}


// LimitType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LimitType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<LimitType3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl LimitType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// LimitType3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum LimitType3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "MULT") )]
	CodeMULT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BILI") )]
	CodeBILI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MAND") )]
	CodeMAND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DISC") )]
	CodeDISC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NELI") )]
	CodeNELI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INBI") )]
	CodeINBI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GLBL") )]
	CodeGLBL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DIDB") )]
	CodeDIDB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SPLC") )]
	CodeSPLC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SPLF") )]
	CodeSPLF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TDLC") )]
	CodeTDLC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TDLF") )]
	CodeTDLF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UCDT") )]
	CodeUCDT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACOL") )]
	CodeACOL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EXGT") )]
	CodeEXGT,
}

impl LimitType3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Limits8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Limits8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CurLmt", skip_serializing_if = "Option::is_none") )]
	pub cur_lmt: Option<Vec<LimitReport8>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DfltLmt", skip_serializing_if = "Option::is_none") )]
	pub dflt_lmt: Option<Vec<LimitReport8>>,
}

impl Limits8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.cur_lmt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.dflt_lmt { for item in vec { item.validate()? } }
		Ok(())
	}
}


// LinkageType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum LinkageType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "LINK") )]
	CodeLINK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UNLK") )]
	CodeUNLK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SOFT") )]
	CodeSOFT,
}

impl LinkageType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// LinkageType3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LinkageType3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<LinkageType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl LinkageType3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// Linkages57 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Linkages57 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrcgPos", skip_serializing_if = "Option::is_none") )]
	pub prcg_pos: Option<ProcessingPosition7Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgNb", skip_serializing_if = "Option::is_none") )]
	pub msg_nb: Option<DocumentNumber5Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ref") )]
	pub ref_attr: References34Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RefOwnr", skip_serializing_if = "Option::is_none") )]
	pub ref_ownr: Option<PartyIdentification127Choice>,
}

impl Linkages57 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.prcg_pos { val.validate()? }
		if let Some(ref val) = self.msg_nb { val.validate()? }
		self.ref_attr.validate()?;
		if let Some(ref val) = self.ref_ownr { val.validate()? }
		Ok(())
	}
}


// LinkedMessage5Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LinkedMessage5Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsRef", skip_serializing_if = "Option::is_none") )]
	pub prvs_ref: Option<AdditionalReference13>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrRef", skip_serializing_if = "Option::is_none") )]
	pub othr_ref: Option<AdditionalReference13>,
}

impl LinkedMessage5Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.prvs_ref { val.validate()? }
		if let Some(ref val) = self.othr_ref { val.validate()? }
		Ok(())
	}
}


// LiquidResourceInformation1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LiquidResourceInformation1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CntrPtyId", skip_serializing_if = "Option::is_none") )]
	pub cntr_pty_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LqdRsrcVal") )]
	pub lqd_rsrc_val: AmountAndDirection102,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktVal", skip_serializing_if = "Option::is_none") )]
	pub mkt_val: Option<AmountAndDirection102>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Scrd") )]
	pub scrd: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AsstNcmbrd") )]
	pub asst_ncmbrd: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QlfygRsrc") )]
	pub qlfyg_rsrc: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AgcyArrgmnts") )]
	pub agcy_arrgmnts: bool,
}

impl LiquidResourceInformation1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cntr_pty_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cntr_pty_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "cntr_pty_id exceeds the maximum length of 35".to_string()));
			}
		}
		self.lqd_rsrc_val.validate()?;
		if let Some(ref val) = self.mkt_val { val.validate()? }
		Ok(())
	}
}


// LiquidResources1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LiquidResources1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshDue") )]
	pub csh_due: Vec<LiquidResourceInformation1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FcltiesCmmtdLinesOfCdt", skip_serializing_if = "Option::is_none") )]
	pub fclties_cmmtd_lines_of_cdt: Option<Vec<LiquidResourceInformation1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FcltiesCmmtdRpAgrmts", skip_serializing_if = "Option::is_none") )]
	pub fclties_cmmtd_rp_agrmts: Option<Vec<LiquidResourceInformation1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FcltiesCmmtdFxSwps", skip_serializing_if = "Option::is_none") )]
	pub fclties_cmmtd_fx_swps: Option<Vec<LiquidResourceInformation1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FcltiesOthrCmmtd", skip_serializing_if = "Option::is_none") )]
	pub fclties_othr_cmmtd: Option<Vec<LiquidResourceInformation1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FcltiesUcmmtd", skip_serializing_if = "Option::is_none") )]
	pub fclties_ucmmtd: Option<Vec<LiquidResourceInformation1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmsCCP", skip_serializing_if = "Option::is_none") )]
	pub fin_instrms_ccp: Option<Vec<LiquidResourceInformation1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmsTrsrInvstmts", skip_serializing_if = "Option::is_none") )]
	pub fin_instrms_trsr_invstmts: Option<Vec<LiquidResourceInformation1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmsDfltrsSttlmColl", skip_serializing_if = "Option::is_none") )]
	pub fin_instrms_dfltrs_sttlm_coll: Option<Vec<LiquidResourceInformation1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmsDfltrsNonCshColl", skip_serializing_if = "Option::is_none") )]
	pub fin_instrms_dfltrs_non_csh_coll: Option<Vec<LiquidResourceInformation1>>,
}

impl LiquidResources1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		for item in &self.csh_due { item.validate()? }
		if let Some(ref vec) = self.fclties_cmmtd_lines_of_cdt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.fclties_cmmtd_rp_agrmts { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.fclties_cmmtd_fx_swps { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.fclties_othr_cmmtd { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.fclties_ucmmtd { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.fin_instrms_ccp { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.fin_instrms_trsr_invstmts { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.fin_instrms_dfltrs_sttlm_coll { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.fin_instrms_dfltrs_non_csh_coll { for item in vec { item.validate()? } }
		Ok(())
	}
}


// LiquidityCreditTransfer4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LiquidityCreditTransfer4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "LqdtyTrfId", skip_serializing_if = "Option::is_none") )]
	pub lqdty_trf_id: Option<PaymentIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cdtr", skip_serializing_if = "Option::is_none") )]
	pub cdtr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAcct", skip_serializing_if = "Option::is_none") )]
	pub cdtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrfdAmt") )]
	pub trfd_amt: Amount2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dbtr", skip_serializing_if = "Option::is_none") )]
	pub dbtr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmDt", skip_serializing_if = "Option::is_none") )]
	pub sttlm_dt: Option<String>,
}

impl LiquidityCreditTransfer4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.lqdty_trf_id { val.validate()? }
		if let Some(ref val) = self.cdtr { val.validate()? }
		if let Some(ref val) = self.cdtr_acct { val.validate()? }
		self.trfd_amt.validate()?;
		if let Some(ref val) = self.dbtr { val.validate()? }
		if let Some(ref val) = self.dbtr_acct { val.validate()? }
		Ok(())
	}
}


// LiquidityDebitTransfer4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LiquidityDebitTransfer4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "LqdtyTrfId", skip_serializing_if = "Option::is_none") )]
	pub lqdty_trf_id: Option<PaymentIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cdtr", skip_serializing_if = "Option::is_none") )]
	pub cdtr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAcct", skip_serializing_if = "Option::is_none") )]
	pub cdtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrfdAmt") )]
	pub trfd_amt: Amount2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dbtr", skip_serializing_if = "Option::is_none") )]
	pub dbtr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmDt", skip_serializing_if = "Option::is_none") )]
	pub sttlm_dt: Option<String>,
}

impl LiquidityDebitTransfer4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.lqdty_trf_id { val.validate()? }
		if let Some(ref val) = self.cdtr { val.validate()? }
		if let Some(ref val) = self.cdtr_acct { val.validate()? }
		self.trfd_amt.validate()?;
		if let Some(ref val) = self.dbtr { val.validate()? }
		if let Some(ref val) = self.dbtr_acct { val.validate()? }
		Ok(())
	}
}


// LiquidityRequiredAndAvailable1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LiquidityRequiredAndAvailable1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "LqdRsrcs") )]
	pub lqd_rsrcs: LiquidResources1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LqdtyHrzn") )]
	pub lqdty_hrzn: SettlementDate6Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StrssLqdRsrcRqrmnt") )]
	pub strss_lqd_rsrc_rqrmnt: StressLiquidResourceRequirement1,
}

impl LiquidityRequiredAndAvailable1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.lqd_rsrcs.validate()?;
		self.lqdty_hrzn.validate()?;
		self.strss_lqd_rsrc_rqrmnt.validate()?;
		Ok(())
	}
}


// LiquidityStressScenarioDefinition1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LiquidityStressScenarioDefinition1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: GenericIdentification168,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Desc") )]
	pub desc: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StrssCcy") )]
	pub strss_ccy: String,
}

impl LiquidityStressScenarioDefinition1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.id.validate()?;
		if self.desc.chars().count() < 1 {
			return Err(ValidationError::new(1001, "desc is shorter than the minimum length of 1".to_string()));
		}
		if self.desc.chars().count() > 2000 {
			return Err(ValidationError::new(1002, "desc exceeds the maximum length of 2000".to_string()));
		}
		if let Some(ref val) = self.tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tp exceeds the maximum length of 35".to_string()));
			}
		}
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.strss_ccy) {
			return Err(ValidationError::new(1005, "strss_ccy does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// LiquidityStressTestResult1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LiquidityStressTestResult1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ScnroDfltrs") )]
	pub scnro_dfltrs: CoverTwoDefaulters1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LqdtyReqrdAndAvlbl") )]
	pub lqdty_reqrd_and_avlbl: Vec<LiquidityRequiredAndAvailable1>,
}

impl LiquidityStressTestResult1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 256 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 256".to_string()));
		}
		self.scnro_dfltrs.validate()?;
		for item in &self.lqdty_reqrd_and_avlbl { item.validate()? }
		Ok(())
	}
}


// LoanContract4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LoanContract4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctDocId") )]
	pub ctrct_doc_id: DocumentIdentification22,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LnTpId", skip_serializing_if = "Option::is_none") )]
	pub ln_tp_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Buyr") )]
	pub buyr: Vec<TradeParty6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sellr") )]
	pub sellr: Vec<TradeParty6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MtrtyDt", skip_serializing_if = "Option::is_none") )]
	pub mtrty_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrlngtnFlg", skip_serializing_if = "Option::is_none") )]
	pub prlngtn_flg: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StartDt", skip_serializing_if = "Option::is_none") )]
	pub start_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmCcy", skip_serializing_if = "Option::is_none") )]
	pub sttlm_ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SpclConds", skip_serializing_if = "Option::is_none") )]
	pub spcl_conds: Option<SpecialCondition1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DrtnCd", skip_serializing_if = "Option::is_none") )]
	pub drtn_cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstRate", skip_serializing_if = "Option::is_none") )]
	pub intrst_rate: Option<InterestRate2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Trch", skip_serializing_if = "Option::is_none") )]
	pub trch: Option<Vec<LoanContractTranche1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtSchdl", skip_serializing_if = "Option::is_none") )]
	pub pmt_schdl: Option<Vec<PaymentSchedule1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstSchdl", skip_serializing_if = "Option::is_none") )]
	pub intrst_schdl: Option<Vec<InterestPaymentSchedule1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntraCpnyLn") )]
	pub intra_cpny_ln: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Coll", skip_serializing_if = "Option::is_none") )]
	pub coll: Option<ContractCollateral1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SndctdLn", skip_serializing_if = "Option::is_none") )]
	pub sndctd_ln: Option<Vec<SyndicatedLoan3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Attchmnt", skip_serializing_if = "Option::is_none") )]
	pub attchmnt: Option<Vec<DocumentGeneralInformation5>>,
}

impl LoanContract4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.ctrct_doc_id.validate()?;
		if let Some(ref val) = self.ln_tp_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ln_tp_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "ln_tp_id exceeds the maximum length of 35".to_string()));
			}
		}
		for item in &self.buyr { item.validate()? }
		for item in &self.sellr { item.validate()? }
		if let Some(ref val) = self.amt { val.validate()? }
		if let Some(ref val) = self.sttlm_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "sttlm_ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.spcl_conds { val.validate()? }
		if let Some(ref val) = self.drtn_cd {
			let pattern = Regex::new("[0-9]").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "drtn_cd does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.intrst_rate { val.validate()? }
		if let Some(ref vec) = self.trch { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.pmt_schdl { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.intrst_schdl { for item in vec { item.validate()? } }
		if let Some(ref val) = self.coll { val.validate()? }
		if let Some(ref vec) = self.sndctd_ln { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.attchmnt { for item in vec { item.validate()? } }
		Ok(())
	}
}


// LoanContractTranche1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LoanContractTranche1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrchNb") )]
	pub trch_nb: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XpctdDt") )]
	pub xpctd_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DueDt", skip_serializing_if = "Option::is_none") )]
	pub due_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DrtnCd", skip_serializing_if = "Option::is_none") )]
	pub drtn_cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LastTrchInd", skip_serializing_if = "Option::is_none") )]
	pub last_trch_ind: Option<bool>,
}

impl LoanContractTranche1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.amt.validate()?;
		if let Some(ref val) = self.drtn_cd {
			let pattern = Regex::new("[0-9]").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "drtn_cd does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// LoanData113 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LoanData113 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnqTradIdr") )]
	pub unq_trad_idr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EvtDt") )]
	pub evt_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktVal") )]
	pub mkt_val: AmountAndDirection53,
}

impl LoanData113 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.unq_trad_idr.chars().count() < 1 {
			return Err(ValidationError::new(1001, "unq_trad_idr is shorter than the minimum length of 1".to_string()));
		}
		if self.unq_trad_idr.chars().count() > 52 {
			return Err(ValidationError::new(1002, "unq_trad_idr exceeds the maximum length of 52".to_string()));
		}
		self.mkt_val.validate()?;
		Ok(())
	}
}


// LoanData120 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LoanData120 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "EvtDt") )]
	pub evt_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnqTradIdr", skip_serializing_if = "Option::is_none") )]
	pub unq_trad_idr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MstrAgrmt", skip_serializing_if = "Option::is_none") )]
	pub mstr_agrmt: Option<MasterAgreement7>,
}

impl LoanData120 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.unq_trad_idr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "unq_trad_idr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 52 {
				return Err(ValidationError::new(1002, "unq_trad_idr exceeds the maximum length of 52".to_string()));
			}
		}
		if let Some(ref val) = self.mstr_agrmt { val.validate()? }
		Ok(())
	}
}


// LoanData134 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LoanData134 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctTp", skip_serializing_if = "Option::is_none") )]
	pub ctrct_tp: Option<ExposureType10Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Clrd", skip_serializing_if = "Option::is_none") )]
	pub clrd: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtflCd", skip_serializing_if = "Option::is_none") )]
	pub prtfl_cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgVn", skip_serializing_if = "Option::is_none") )]
	pub tradg_vn: Option<TradingVenueType1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MstrAgrmtTp", skip_serializing_if = "Option::is_none") )]
	pub mstr_agrmt_tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MtrtyDt", skip_serializing_if = "Option::is_none") )]
	pub mtrty_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GnlColl", skip_serializing_if = "Option::is_none") )]
	pub gnl_coll: Option<SpecialCollateral1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Term", skip_serializing_if = "Option::is_none") )]
	pub term: Option<ContractTerm6Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rates", skip_serializing_if = "Option::is_none") )]
	pub rates: Option<Rates1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrncplAmtCcy", skip_serializing_if = "Option::is_none") )]
	pub prncpl_amt_ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PricCcy", skip_serializing_if = "Option::is_none") )]
	pub pric_ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Scty", skip_serializing_if = "Option::is_none") )]
	pub scty: Option<Security49>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OutsdngMrgnLnCcy", skip_serializing_if = "Option::is_none") )]
	pub outsdng_mrgn_ln_ccy: Option<String>,
}

impl LoanData134 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ctrct_tp { val.validate()? }
		if let Some(ref val) = self.prtfl_cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtfl_cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 52 {
				return Err(ValidationError::new(1002, "prtfl_cd exceeds the maximum length of 52".to_string()));
			}
		}
		if let Some(ref val) = self.tradg_vn { val.validate()? }
		if let Some(ref val) = self.mstr_agrmt_tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mstr_agrmt_tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "mstr_agrmt_tp exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.gnl_coll { val.validate()? }
		if let Some(ref val) = self.term { val.validate()? }
		if let Some(ref val) = self.rates { val.validate()? }
		if let Some(ref val) = self.prncpl_amt_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "prncpl_amt_ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.pric_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "pric_ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.scty { val.validate()? }
		if let Some(ref val) = self.outsdng_mrgn_ln_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "outsdng_mrgn_ln_ccy does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// LoanData135 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LoanData135 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnqTradIdr") )]
	pub unq_trad_idr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EvtDt") )]
	pub evt_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExctnDtTm") )]
	pub exctn_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrSts", skip_serializing_if = "Option::is_none") )]
	pub clr_sts: Option<Cleared16Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgVn", skip_serializing_if = "Option::is_none") )]
	pub tradg_vn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MstrAgrmt", skip_serializing_if = "Option::is_none") )]
	pub mstr_agrmt: Option<MasterAgreement7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValDt", skip_serializing_if = "Option::is_none") )]
	pub val_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MinNtcePrd", skip_serializing_if = "Option::is_none") )]
	pub min_ntce_prd: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EarlstCallBckDt", skip_serializing_if = "Option::is_none") )]
	pub earlst_call_bck_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GnlColl", skip_serializing_if = "Option::is_none") )]
	pub gnl_coll: Option<SpecialCollateral1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DlvryByVal", skip_serializing_if = "Option::is_none") )]
	pub dlvry_by_val: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollDlvryMtd", skip_serializing_if = "Option::is_none") )]
	pub coll_dlvry_mtd: Option<CollateralDeliveryMethod1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Term", skip_serializing_if = "Option::is_none") )]
	pub term: Option<Vec<ContractTerm7Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstRate", skip_serializing_if = "Option::is_none") )]
	pub intrst_rate: Option<InterestRate27Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrncplAmt", skip_serializing_if = "Option::is_none") )]
	pub prncpl_amt: Option<PrincipalAmount3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TermntnDt", skip_serializing_if = "Option::is_none") )]
	pub termntn_dt: Option<String>,
}

impl LoanData135 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.unq_trad_idr.chars().count() < 1 {
			return Err(ValidationError::new(1001, "unq_trad_idr is shorter than the minimum length of 1".to_string()));
		}
		if self.unq_trad_idr.chars().count() > 52 {
			return Err(ValidationError::new(1002, "unq_trad_idr exceeds the maximum length of 52".to_string()));
		}
		if let Some(ref val) = self.clr_sts { val.validate()? }
		if let Some(ref val) = self.tradg_vn {
			let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "tradg_vn does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.mstr_agrmt { val.validate()? }
		if let Some(ref val) = self.min_ntce_prd {
			if *val < 0.000000 {
				return Err(ValidationError::new(1003, "min_ntce_prd is less than the minimum value of 0.000000".to_string()));
			}
		}
		if let Some(ref val) = self.gnl_coll { val.validate()? }
		if let Some(ref val) = self.coll_dlvry_mtd { val.validate()? }
		if let Some(ref vec) = self.term { for item in vec { item.validate()? } }
		if let Some(ref val) = self.intrst_rate { val.validate()? }
		if let Some(ref val) = self.prncpl_amt { val.validate()? }
		Ok(())
	}
}


// LoanData136 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LoanData136 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnqTradIdr") )]
	pub unq_trad_idr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EvtDt") )]
	pub evt_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExctnDtTm") )]
	pub exctn_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrSts", skip_serializing_if = "Option::is_none") )]
	pub clr_sts: Option<Cleared16Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgVn", skip_serializing_if = "Option::is_none") )]
	pub tradg_vn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MstrAgrmt", skip_serializing_if = "Option::is_none") )]
	pub mstr_agrmt: Option<MasterAgreement7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValDt", skip_serializing_if = "Option::is_none") )]
	pub val_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MtrtyDt", skip_serializing_if = "Option::is_none") )]
	pub mtrty_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GnlColl", skip_serializing_if = "Option::is_none") )]
	pub gnl_coll: Option<SpecialCollateral1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrncplAmt", skip_serializing_if = "Option::is_none") )]
	pub prncpl_amt: Option<PrincipalAmount3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnitPric", skip_serializing_if = "Option::is_none") )]
	pub unit_pric: Option<SecuritiesTransactionPrice19Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TermntnDt", skip_serializing_if = "Option::is_none") )]
	pub termntn_dt: Option<String>,
}

impl LoanData136 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.unq_trad_idr.chars().count() < 1 {
			return Err(ValidationError::new(1001, "unq_trad_idr is shorter than the minimum length of 1".to_string()));
		}
		if self.unq_trad_idr.chars().count() > 52 {
			return Err(ValidationError::new(1002, "unq_trad_idr exceeds the maximum length of 52".to_string()));
		}
		if let Some(ref val) = self.clr_sts { val.validate()? }
		if let Some(ref val) = self.tradg_vn {
			let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "tradg_vn does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.mstr_agrmt { val.validate()? }
		if let Some(ref val) = self.gnl_coll { val.validate()? }
		if let Some(ref val) = self.prncpl_amt { val.validate()? }
		if let Some(ref val) = self.unit_pric { val.validate()? }
		Ok(())
	}
}


// LoanData137 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LoanData137 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnqTradIdr") )]
	pub unq_trad_idr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EvtDt") )]
	pub evt_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExctnDtTm") )]
	pub exctn_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrSts", skip_serializing_if = "Option::is_none") )]
	pub clr_sts: Option<Cleared16Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgVn", skip_serializing_if = "Option::is_none") )]
	pub tradg_vn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MstrAgrmt", skip_serializing_if = "Option::is_none") )]
	pub mstr_agrmt: Option<MasterAgreement7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValDt", skip_serializing_if = "Option::is_none") )]
	pub val_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GnlColl", skip_serializing_if = "Option::is_none") )]
	pub gnl_coll: Option<SpecialCollateral1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DlvryByVal", skip_serializing_if = "Option::is_none") )]
	pub dlvry_by_val: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollDlvryMtd", skip_serializing_if = "Option::is_none") )]
	pub coll_dlvry_mtd: Option<CollateralDeliveryMethod1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Term", skip_serializing_if = "Option::is_none") )]
	pub term: Option<Vec<ContractTerm7Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AsstTp", skip_serializing_if = "Option::is_none") )]
	pub asst_tp: Option<SecurityCommodity9>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LnVal", skip_serializing_if = "Option::is_none") )]
	pub ln_val: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RbtRate", skip_serializing_if = "Option::is_none") )]
	pub rbt_rate: Option<InterestRate27Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LndgFee", skip_serializing_if = "Option::is_none") )]
	pub lndg_fee: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TermntnDt", skip_serializing_if = "Option::is_none") )]
	pub termntn_dt: Option<String>,
}

impl LoanData137 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.unq_trad_idr.chars().count() < 1 {
			return Err(ValidationError::new(1001, "unq_trad_idr is shorter than the minimum length of 1".to_string()));
		}
		if self.unq_trad_idr.chars().count() > 52 {
			return Err(ValidationError::new(1002, "unq_trad_idr exceeds the maximum length of 52".to_string()));
		}
		if let Some(ref val) = self.clr_sts { val.validate()? }
		if let Some(ref val) = self.tradg_vn {
			let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "tradg_vn does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.mstr_agrmt { val.validate()? }
		if let Some(ref val) = self.gnl_coll { val.validate()? }
		if let Some(ref val) = self.coll_dlvry_mtd { val.validate()? }
		if let Some(ref vec) = self.term { for item in vec { item.validate()? } }
		if let Some(ref val) = self.asst_tp { val.validate()? }
		if let Some(ref val) = self.ln_val { val.validate()? }
		if let Some(ref val) = self.rbt_rate { val.validate()? }
		Ok(())
	}
}


// LoanData138 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LoanData138 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnqTradIdr") )]
	pub unq_trad_idr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EvtDt") )]
	pub evt_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExctnDtTm") )]
	pub exctn_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgVn", skip_serializing_if = "Option::is_none") )]
	pub tradg_vn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollDlvryMtd", skip_serializing_if = "Option::is_none") )]
	pub coll_dlvry_mtd: Option<CollateralDeliveryMethod1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OutsdngMrgnLnAmt", skip_serializing_if = "Option::is_none") )]
	pub outsdng_mrgn_ln_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ShrtMktValAmt", skip_serializing_if = "Option::is_none") )]
	pub shrt_mkt_val_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MrgnLnAttr", skip_serializing_if = "Option::is_none") )]
	pub mrgn_ln_attr: Option<Vec<InterestRate6>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TermntnDt", skip_serializing_if = "Option::is_none") )]
	pub termntn_dt: Option<String>,
}

impl LoanData138 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.unq_trad_idr.chars().count() < 1 {
			return Err(ValidationError::new(1001, "unq_trad_idr is shorter than the minimum length of 1".to_string()));
		}
		if self.unq_trad_idr.chars().count() > 52 {
			return Err(ValidationError::new(1002, "unq_trad_idr exceeds the maximum length of 52".to_string()));
		}
		if let Some(ref val) = self.tradg_vn {
			let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "tradg_vn does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.coll_dlvry_mtd { val.validate()? }
		if let Some(ref val) = self.outsdng_mrgn_ln_amt { val.validate()? }
		if let Some(ref val) = self.shrt_mkt_val_amt { val.validate()? }
		if let Some(ref vec) = self.mrgn_ln_attr { for item in vec { item.validate()? } }
		Ok(())
	}
}


// LoanData139 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LoanData139 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnqTradIdr", skip_serializing_if = "Option::is_none") )]
	pub unq_trad_idr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EvtDt", skip_serializing_if = "Option::is_none") )]
	pub evt_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExctnDtTm", skip_serializing_if = "Option::is_none") )]
	pub exctn_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrSts", skip_serializing_if = "Option::is_none") )]
	pub clr_sts: Option<Cleared16Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgVn", skip_serializing_if = "Option::is_none") )]
	pub tradg_vn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MstrAgrmt", skip_serializing_if = "Option::is_none") )]
	pub mstr_agrmt: Option<MasterAgreement7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValDt", skip_serializing_if = "Option::is_none") )]
	pub val_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MinNtcePrd", skip_serializing_if = "Option::is_none") )]
	pub min_ntce_prd: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EarlstCallBckDt", skip_serializing_if = "Option::is_none") )]
	pub earlst_call_bck_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GnlColl", skip_serializing_if = "Option::is_none") )]
	pub gnl_coll: Option<SpecialCollateral1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DlvryByVal", skip_serializing_if = "Option::is_none") )]
	pub dlvry_by_val: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollDlvryMtd", skip_serializing_if = "Option::is_none") )]
	pub coll_dlvry_mtd: Option<CollateralDeliveryMethod1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Term", skip_serializing_if = "Option::is_none") )]
	pub term: Option<Vec<ContractTerm7Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstRate", skip_serializing_if = "Option::is_none") )]
	pub intrst_rate: Option<InterestRate27Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrncplAmt", skip_serializing_if = "Option::is_none") )]
	pub prncpl_amt: Option<PrincipalAmount3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TermntnDt", skip_serializing_if = "Option::is_none") )]
	pub termntn_dt: Option<String>,
}

impl LoanData139 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.unq_trad_idr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "unq_trad_idr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 52 {
				return Err(ValidationError::new(1002, "unq_trad_idr exceeds the maximum length of 52".to_string()));
			}
		}
		if let Some(ref val) = self.clr_sts { val.validate()? }
		if let Some(ref val) = self.tradg_vn {
			let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "tradg_vn does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.mstr_agrmt { val.validate()? }
		if let Some(ref val) = self.min_ntce_prd {
			if *val < 0.000000 {
				return Err(ValidationError::new(1003, "min_ntce_prd is less than the minimum value of 0.000000".to_string()));
			}
		}
		if let Some(ref val) = self.gnl_coll { val.validate()? }
		if let Some(ref val) = self.coll_dlvry_mtd { val.validate()? }
		if let Some(ref vec) = self.term { for item in vec { item.validate()? } }
		if let Some(ref val) = self.intrst_rate { val.validate()? }
		if let Some(ref val) = self.prncpl_amt { val.validate()? }
		Ok(())
	}
}


// LoanData140 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LoanData140 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnqTradIdr", skip_serializing_if = "Option::is_none") )]
	pub unq_trad_idr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EvtDt") )]
	pub evt_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExctnDtTm", skip_serializing_if = "Option::is_none") )]
	pub exctn_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrSts", skip_serializing_if = "Option::is_none") )]
	pub clr_sts: Option<Cleared16Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgVn", skip_serializing_if = "Option::is_none") )]
	pub tradg_vn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MstrAgrmt", skip_serializing_if = "Option::is_none") )]
	pub mstr_agrmt: Option<MasterAgreement7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValDt", skip_serializing_if = "Option::is_none") )]
	pub val_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MtrtyDt", skip_serializing_if = "Option::is_none") )]
	pub mtrty_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GnlColl", skip_serializing_if = "Option::is_none") )]
	pub gnl_coll: Option<SpecialCollateral1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrncplAmt", skip_serializing_if = "Option::is_none") )]
	pub prncpl_amt: Option<PrincipalAmount3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnitPric", skip_serializing_if = "Option::is_none") )]
	pub unit_pric: Option<SecuritiesTransactionPrice19Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TermntnDt", skip_serializing_if = "Option::is_none") )]
	pub termntn_dt: Option<String>,
}

impl LoanData140 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.unq_trad_idr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "unq_trad_idr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 52 {
				return Err(ValidationError::new(1002, "unq_trad_idr exceeds the maximum length of 52".to_string()));
			}
		}
		if let Some(ref val) = self.clr_sts { val.validate()? }
		if let Some(ref val) = self.tradg_vn {
			let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "tradg_vn does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.mstr_agrmt { val.validate()? }
		if let Some(ref val) = self.gnl_coll { val.validate()? }
		if let Some(ref val) = self.prncpl_amt { val.validate()? }
		if let Some(ref val) = self.unit_pric { val.validate()? }
		Ok(())
	}
}


// LoanData141 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LoanData141 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnqTradIdr", skip_serializing_if = "Option::is_none") )]
	pub unq_trad_idr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EvtDt") )]
	pub evt_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExctnDtTm", skip_serializing_if = "Option::is_none") )]
	pub exctn_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrSts", skip_serializing_if = "Option::is_none") )]
	pub clr_sts: Option<Cleared16Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgVn", skip_serializing_if = "Option::is_none") )]
	pub tradg_vn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MstrAgrmt", skip_serializing_if = "Option::is_none") )]
	pub mstr_agrmt: Option<MasterAgreement7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValDt", skip_serializing_if = "Option::is_none") )]
	pub val_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GnlColl", skip_serializing_if = "Option::is_none") )]
	pub gnl_coll: Option<SpecialCollateral1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DlvryByVal", skip_serializing_if = "Option::is_none") )]
	pub dlvry_by_val: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollDlvryMtd", skip_serializing_if = "Option::is_none") )]
	pub coll_dlvry_mtd: Option<CollateralDeliveryMethod1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Term", skip_serializing_if = "Option::is_none") )]
	pub term: Option<Vec<ContractTerm7Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AsstTp", skip_serializing_if = "Option::is_none") )]
	pub asst_tp: Option<SecurityCommodity9>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LnVal", skip_serializing_if = "Option::is_none") )]
	pub ln_val: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RbtRate", skip_serializing_if = "Option::is_none") )]
	pub rbt_rate: Option<InterestRate27Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LndgFee", skip_serializing_if = "Option::is_none") )]
	pub lndg_fee: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TermntnDt", skip_serializing_if = "Option::is_none") )]
	pub termntn_dt: Option<String>,
}

impl LoanData141 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.unq_trad_idr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "unq_trad_idr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 52 {
				return Err(ValidationError::new(1002, "unq_trad_idr exceeds the maximum length of 52".to_string()));
			}
		}
		if let Some(ref val) = self.clr_sts { val.validate()? }
		if let Some(ref val) = self.tradg_vn {
			let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "tradg_vn does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.mstr_agrmt { val.validate()? }
		if let Some(ref val) = self.gnl_coll { val.validate()? }
		if let Some(ref val) = self.coll_dlvry_mtd { val.validate()? }
		if let Some(ref vec) = self.term { for item in vec { item.validate()? } }
		if let Some(ref val) = self.asst_tp { val.validate()? }
		if let Some(ref val) = self.ln_val { val.validate()? }
		if let Some(ref val) = self.rbt_rate { val.validate()? }
		Ok(())
	}
}


// LoanData142 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LoanData142 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnqTradIdr", skip_serializing_if = "Option::is_none") )]
	pub unq_trad_idr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EvtDt") )]
	pub evt_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExctnDtTm", skip_serializing_if = "Option::is_none") )]
	pub exctn_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgVn", skip_serializing_if = "Option::is_none") )]
	pub tradg_vn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollDlvryMtd", skip_serializing_if = "Option::is_none") )]
	pub coll_dlvry_mtd: Option<CollateralDeliveryMethod1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OutsdngMrgnLnAmt", skip_serializing_if = "Option::is_none") )]
	pub outsdng_mrgn_ln_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ShrtMktValAmt", skip_serializing_if = "Option::is_none") )]
	pub shrt_mkt_val_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MrgnLnAttr", skip_serializing_if = "Option::is_none") )]
	pub mrgn_ln_attr: Option<Vec<InterestRate6>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TermntnDt", skip_serializing_if = "Option::is_none") )]
	pub termntn_dt: Option<String>,
}

impl LoanData142 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.unq_trad_idr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "unq_trad_idr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 52 {
				return Err(ValidationError::new(1002, "unq_trad_idr exceeds the maximum length of 52".to_string()));
			}
		}
		if let Some(ref val) = self.tradg_vn {
			let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "tradg_vn does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.coll_dlvry_mtd { val.validate()? }
		if let Some(ref val) = self.outsdng_mrgn_ln_amt { val.validate()? }
		if let Some(ref val) = self.shrt_mkt_val_amt { val.validate()? }
		if let Some(ref vec) = self.mrgn_ln_attr { for item in vec { item.validate()? } }
		Ok(())
	}
}


// LoanData143 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LoanData143 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnqTradIdr") )]
	pub unq_trad_idr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EvtDt") )]
	pub evt_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExctnDtTm") )]
	pub exctn_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrSts") )]
	pub clr_sts: Cleared16Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgVn") )]
	pub tradg_vn: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MstrAgrmt", skip_serializing_if = "Option::is_none") )]
	pub mstr_agrmt: Option<MasterAgreement7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValDt") )]
	pub val_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GnlColl", skip_serializing_if = "Option::is_none") )]
	pub gnl_coll: Option<SpecialCollateral1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DlvryByVal") )]
	pub dlvry_by_val: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollDlvryMtd") )]
	pub coll_dlvry_mtd: CollateralDeliveryMethod1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Term", skip_serializing_if = "Option::is_none") )]
	pub term: Option<Vec<ContractTerm7Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstRate", skip_serializing_if = "Option::is_none") )]
	pub intrst_rate: Option<InterestRate27Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrncplAmt", skip_serializing_if = "Option::is_none") )]
	pub prncpl_amt: Option<PrincipalAmount3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TermntnDt", skip_serializing_if = "Option::is_none") )]
	pub termntn_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnitPric", skip_serializing_if = "Option::is_none") )]
	pub unit_pric: Option<SecuritiesTransactionPrice19Choice>,
}

impl LoanData143 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.unq_trad_idr.chars().count() < 1 {
			return Err(ValidationError::new(1001, "unq_trad_idr is shorter than the minimum length of 1".to_string()));
		}
		if self.unq_trad_idr.chars().count() > 52 {
			return Err(ValidationError::new(1002, "unq_trad_idr exceeds the maximum length of 52".to_string()));
		}
		self.clr_sts.validate()?;
		let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
		if !pattern.is_match(&self.tradg_vn) {
			return Err(ValidationError::new(1005, "tradg_vn does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.mstr_agrmt { val.validate()? }
		if let Some(ref val) = self.gnl_coll { val.validate()? }
		self.coll_dlvry_mtd.validate()?;
		if let Some(ref vec) = self.term { for item in vec { item.validate()? } }
		if let Some(ref val) = self.intrst_rate { val.validate()? }
		if let Some(ref val) = self.prncpl_amt { val.validate()? }
		if let Some(ref val) = self.unit_pric { val.validate()? }
		Ok(())
	}
}


// LoanData144 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LoanData144 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrncplAmt", skip_serializing_if = "Option::is_none") )]
	pub prncpl_amt: Option<PrincipalAmount3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MtrtyDt") )]
	pub mtrty_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnqTradIdr") )]
	pub unq_trad_idr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EvtDt") )]
	pub evt_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrSts") )]
	pub clr_sts: Cleared16Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgVn") )]
	pub tradg_vn: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MstrAgrmt", skip_serializing_if = "Option::is_none") )]
	pub mstr_agrmt: Option<MasterAgreement7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExctnDtTm") )]
	pub exctn_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValDt") )]
	pub val_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TermntnDt", skip_serializing_if = "Option::is_none") )]
	pub termntn_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GnlColl", skip_serializing_if = "Option::is_none") )]
	pub gnl_coll: Option<SpecialCollateral1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnitPric", skip_serializing_if = "Option::is_none") )]
	pub unit_pric: Option<SecuritiesTransactionPrice19Choice>,
}

impl LoanData144 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.prncpl_amt { val.validate()? }
		if self.unq_trad_idr.chars().count() < 1 {
			return Err(ValidationError::new(1001, "unq_trad_idr is shorter than the minimum length of 1".to_string()));
		}
		if self.unq_trad_idr.chars().count() > 52 {
			return Err(ValidationError::new(1002, "unq_trad_idr exceeds the maximum length of 52".to_string()));
		}
		self.clr_sts.validate()?;
		let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
		if !pattern.is_match(&self.tradg_vn) {
			return Err(ValidationError::new(1005, "tradg_vn does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.mstr_agrmt { val.validate()? }
		if let Some(ref val) = self.gnl_coll { val.validate()? }
		if let Some(ref val) = self.unit_pric { val.validate()? }
		Ok(())
	}
}


// LoanData145 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LoanData145 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DlvryByVal") )]
	pub dlvry_by_val: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollDlvryMtd", skip_serializing_if = "Option::is_none") )]
	pub coll_dlvry_mtd: Option<CollateralDeliveryMethod1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Term", skip_serializing_if = "Option::is_none") )]
	pub term: Option<Vec<ContractTerm7Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AsstTp") )]
	pub asst_tp: SecurityCommodity9,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RbtRate", skip_serializing_if = "Option::is_none") )]
	pub rbt_rate: Option<InterestRate27Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LnVal") )]
	pub ln_val: ActiveOrHistoricCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LndgFee", skip_serializing_if = "Option::is_none") )]
	pub lndg_fee: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnqTradIdr") )]
	pub unq_trad_idr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EvtDt") )]
	pub evt_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrSts") )]
	pub clr_sts: Cleared16Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgVn") )]
	pub tradg_vn: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MstrAgrmt", skip_serializing_if = "Option::is_none") )]
	pub mstr_agrmt: Option<MasterAgreement7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExctnDtTm") )]
	pub exctn_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValDt") )]
	pub val_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TermntnDt", skip_serializing_if = "Option::is_none") )]
	pub termntn_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GnlColl", skip_serializing_if = "Option::is_none") )]
	pub gnl_coll: Option<SpecialCollateral1Code>,
}

impl LoanData145 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.coll_dlvry_mtd { val.validate()? }
		if let Some(ref vec) = self.term { for item in vec { item.validate()? } }
		self.asst_tp.validate()?;
		if let Some(ref val) = self.rbt_rate { val.validate()? }
		self.ln_val.validate()?;
		if self.unq_trad_idr.chars().count() < 1 {
			return Err(ValidationError::new(1001, "unq_trad_idr is shorter than the minimum length of 1".to_string()));
		}
		if self.unq_trad_idr.chars().count() > 52 {
			return Err(ValidationError::new(1002, "unq_trad_idr exceeds the maximum length of 52".to_string()));
		}
		self.clr_sts.validate()?;
		let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
		if !pattern.is_match(&self.tradg_vn) {
			return Err(ValidationError::new(1005, "tradg_vn does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.mstr_agrmt { val.validate()? }
		if let Some(ref val) = self.gnl_coll { val.validate()? }
		Ok(())
	}
}


// LoanData86 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LoanData86 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnqTradIdr") )]
	pub unq_trad_idr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EvtDt", skip_serializing_if = "Option::is_none") )]
	pub evt_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TermntnDt", skip_serializing_if = "Option::is_none") )]
	pub termntn_dt: Option<String>,
}

impl LoanData86 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.unq_trad_idr.chars().count() < 1 {
			return Err(ValidationError::new(1001, "unq_trad_idr is shorter than the minimum length of 1".to_string()));
		}
		if self.unq_trad_idr.chars().count() > 52 {
			return Err(ValidationError::new(1002, "unq_trad_idr exceeds the maximum length of 52".to_string()));
		}
		Ok(())
	}
}


// LoanMatchingCriteria9 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LoanMatchingCriteria9 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnqTradIdr", skip_serializing_if = "Option::is_none") )]
	pub unq_trad_idr: Option<CompareText2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TermntnDt", skip_serializing_if = "Option::is_none") )]
	pub termntn_dt: Option<CompareDate3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctTp", skip_serializing_if = "Option::is_none") )]
	pub ctrct_tp: Option<CompareExposureType3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrSts", skip_serializing_if = "Option::is_none") )]
	pub clr_sts: Option<CompareClearingStatus3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrDtTm", skip_serializing_if = "Option::is_none") )]
	pub clr_dt_tm: Option<CompareDateTime3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CCP", skip_serializing_if = "Option::is_none") )]
	pub ccp: Option<CompareOrganisationIdentification6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgVn", skip_serializing_if = "Option::is_none") )]
	pub tradg_vn: Option<CompareMICIdentifier3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MstrAgrmtTp", skip_serializing_if = "Option::is_none") )]
	pub mstr_agrmt_tp: Option<CompareAgreementType2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExctnDtTm", skip_serializing_if = "Option::is_none") )]
	pub exctn_dt_tm: Option<CompareDateTime3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValDt", skip_serializing_if = "Option::is_none") )]
	pub val_dt: Option<CompareDate3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MtrtyDt", skip_serializing_if = "Option::is_none") )]
	pub mtrty_dt: Option<CompareDate3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MinNtcePrd", skip_serializing_if = "Option::is_none") )]
	pub min_ntce_prd: Option<CompareNumber5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EarlstCallBckDt", skip_serializing_if = "Option::is_none") )]
	pub earlst_call_bck_dt: Option<CompareDate3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GnlColl", skip_serializing_if = "Option::is_none") )]
	pub gnl_coll: Option<CompareSpecialCollateral3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DlvryByVal", skip_serializing_if = "Option::is_none") )]
	pub dlvry_by_val: Option<CompareTrueFalseIndicator3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollDlvryMtd", skip_serializing_if = "Option::is_none") )]
	pub coll_dlvry_mtd: Option<CompareDeliveryMethod3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OpnTerm", skip_serializing_if = "Option::is_none") )]
	pub opn_term: Option<CompareTrueFalseIndicator3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TermntnOptn", skip_serializing_if = "Option::is_none") )]
	pub termntn_optn: Option<CompareTerminationOption3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FxdIntrstRate", skip_serializing_if = "Option::is_none") )]
	pub fxd_intrst_rate: Option<ComparePercentageRate3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DayCntBsis", skip_serializing_if = "Option::is_none") )]
	pub day_cnt_bsis: Option<CompareInterestComputationMethod3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FltgIntrstRefRate", skip_serializing_if = "Option::is_none") )]
	pub fltg_intrst_ref_rate: Option<CompareBenchmarkCurveName3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FltgIntrstRateTermUnit", skip_serializing_if = "Option::is_none") )]
	pub fltg_intrst_rate_term_unit: Option<CompareRateBasis3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FltgIntrstRateTermVal", skip_serializing_if = "Option::is_none") )]
	pub fltg_intrst_rate_term_val: Option<CompareNumber5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FltgIntrstRatePmtFrqcyUnit", skip_serializing_if = "Option::is_none") )]
	pub fltg_intrst_rate_pmt_frqcy_unit: Option<CompareRateBasis3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FltgIntrstRatePmtFrqcyVal", skip_serializing_if = "Option::is_none") )]
	pub fltg_intrst_rate_pmt_frqcy_val: Option<CompareNumber5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FltgIntrstRateRstFrqcyUnit", skip_serializing_if = "Option::is_none") )]
	pub fltg_intrst_rate_rst_frqcy_unit: Option<CompareRateBasis3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FltgIntrstRateRstFrqcyVal", skip_serializing_if = "Option::is_none") )]
	pub fltg_intrst_rate_rst_frqcy_val: Option<CompareNumber6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BsisPtSprd", skip_serializing_if = "Option::is_none") )]
	pub bsis_pt_sprd: Option<CompareDecimalNumber3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MrgnLnAttr", skip_serializing_if = "Option::is_none") )]
	pub mrgn_ln_attr: Option<Vec<CompareInterestRate1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrncplAmtValDtAmt", skip_serializing_if = "Option::is_none") )]
	pub prncpl_amt_val_dt_amt: Option<CompareActiveOrHistoricCurrencyAndAmount3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrncplAmtMtrtyDtAmt", skip_serializing_if = "Option::is_none") )]
	pub prncpl_amt_mtrty_dt_amt: Option<CompareActiveOrHistoricCurrencyAndAmount3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AsstTp", skip_serializing_if = "Option::is_none") )]
	pub asst_tp: Option<SecurityCommodity7Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LnVal", skip_serializing_if = "Option::is_none") )]
	pub ln_val: Option<CompareActiveOrHistoricCurrencyAndAmount3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FxdRbtRefRate", skip_serializing_if = "Option::is_none") )]
	pub fxd_rbt_ref_rate: Option<ComparePercentageRate3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FltgRbtRefRate", skip_serializing_if = "Option::is_none") )]
	pub fltg_rbt_ref_rate: Option<CompareBenchmarkCurveName3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FltgRbtRateTermUnit", skip_serializing_if = "Option::is_none") )]
	pub fltg_rbt_rate_term_unit: Option<CompareRateBasis3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FltgRbtRateTermVal", skip_serializing_if = "Option::is_none") )]
	pub fltg_rbt_rate_term_val: Option<CompareNumber6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FltgRbtRatePmtFrqcyUnit", skip_serializing_if = "Option::is_none") )]
	pub fltg_rbt_rate_pmt_frqcy_unit: Option<CompareRateBasis3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FltgRbtRatePmtFrqcyVal", skip_serializing_if = "Option::is_none") )]
	pub fltg_rbt_rate_pmt_frqcy_val: Option<CompareNumber6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FltgRbtRateRstFrqcyUnit", skip_serializing_if = "Option::is_none") )]
	pub fltg_rbt_rate_rst_frqcy_unit: Option<CompareRateBasis3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FltgRbtRateRstFrqcyVal", skip_serializing_if = "Option::is_none") )]
	pub fltg_rbt_rate_rst_frqcy_val: Option<CompareNumber6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RbtRateBsisPtSprd", skip_serializing_if = "Option::is_none") )]
	pub rbt_rate_bsis_pt_sprd: Option<CompareDecimalNumber3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FltgRateAdjstmnt", skip_serializing_if = "Option::is_none") )]
	pub fltg_rate_adjstmnt: Option<Vec<ComparePercentageRate3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FltgRateAdjstmntDt", skip_serializing_if = "Option::is_none") )]
	pub fltg_rate_adjstmnt_dt: Option<Vec<CompareDate3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LndgFee", skip_serializing_if = "Option::is_none") )]
	pub lndg_fee: Option<ComparePercentageRate3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OutsdngMrgnLnAmt", skip_serializing_if = "Option::is_none") )]
	pub outsdng_mrgn_ln_amt: Option<CompareActiveOrHistoricCurrencyAndAmount3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ShrtMktValAmt", skip_serializing_if = "Option::is_none") )]
	pub shrt_mkt_val_amt: Option<CompareActiveOrHistoricCurrencyAndAmount3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LvlTp", skip_serializing_if = "Option::is_none") )]
	pub lvl_tp: Option<CompareReportingLevelType3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnitOfMeasr", skip_serializing_if = "Option::is_none") )]
	pub unit_of_measr: Option<CompareUnitOfMeasure3>,
}

impl LoanMatchingCriteria9 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.unq_trad_idr { val.validate()? }
		if let Some(ref val) = self.termntn_dt { val.validate()? }
		if let Some(ref val) = self.ctrct_tp { val.validate()? }
		if let Some(ref val) = self.clr_sts { val.validate()? }
		if let Some(ref val) = self.clr_dt_tm { val.validate()? }
		if let Some(ref val) = self.ccp { val.validate()? }
		if let Some(ref val) = self.tradg_vn { val.validate()? }
		if let Some(ref val) = self.mstr_agrmt_tp { val.validate()? }
		if let Some(ref val) = self.exctn_dt_tm { val.validate()? }
		if let Some(ref val) = self.val_dt { val.validate()? }
		if let Some(ref val) = self.mtrty_dt { val.validate()? }
		if let Some(ref val) = self.min_ntce_prd { val.validate()? }
		if let Some(ref val) = self.earlst_call_bck_dt { val.validate()? }
		if let Some(ref val) = self.gnl_coll { val.validate()? }
		if let Some(ref val) = self.dlvry_by_val { val.validate()? }
		if let Some(ref val) = self.coll_dlvry_mtd { val.validate()? }
		if let Some(ref val) = self.opn_term { val.validate()? }
		if let Some(ref val) = self.termntn_optn { val.validate()? }
		if let Some(ref val) = self.fxd_intrst_rate { val.validate()? }
		if let Some(ref val) = self.day_cnt_bsis { val.validate()? }
		if let Some(ref val) = self.fltg_intrst_ref_rate { val.validate()? }
		if let Some(ref val) = self.fltg_intrst_rate_term_unit { val.validate()? }
		if let Some(ref val) = self.fltg_intrst_rate_term_val { val.validate()? }
		if let Some(ref val) = self.fltg_intrst_rate_pmt_frqcy_unit { val.validate()? }
		if let Some(ref val) = self.fltg_intrst_rate_pmt_frqcy_val { val.validate()? }
		if let Some(ref val) = self.fltg_intrst_rate_rst_frqcy_unit { val.validate()? }
		if let Some(ref val) = self.fltg_intrst_rate_rst_frqcy_val { val.validate()? }
		if let Some(ref val) = self.bsis_pt_sprd { val.validate()? }
		if let Some(ref vec) = self.mrgn_ln_attr { for item in vec { item.validate()? } }
		if let Some(ref val) = self.prncpl_amt_val_dt_amt { val.validate()? }
		if let Some(ref val) = self.prncpl_amt_mtrty_dt_amt { val.validate()? }
		if let Some(ref val) = self.asst_tp { val.validate()? }
		if let Some(ref val) = self.ln_val { val.validate()? }
		if let Some(ref val) = self.fxd_rbt_ref_rate { val.validate()? }
		if let Some(ref val) = self.fltg_rbt_ref_rate { val.validate()? }
		if let Some(ref val) = self.fltg_rbt_rate_term_unit { val.validate()? }
		if let Some(ref val) = self.fltg_rbt_rate_term_val { val.validate()? }
		if let Some(ref val) = self.fltg_rbt_rate_pmt_frqcy_unit { val.validate()? }
		if let Some(ref val) = self.fltg_rbt_rate_pmt_frqcy_val { val.validate()? }
		if let Some(ref val) = self.fltg_rbt_rate_rst_frqcy_unit { val.validate()? }
		if let Some(ref val) = self.fltg_rbt_rate_rst_frqcy_val { val.validate()? }
		if let Some(ref val) = self.rbt_rate_bsis_pt_sprd { val.validate()? }
		if let Some(ref vec) = self.fltg_rate_adjstmnt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.fltg_rate_adjstmnt_dt { for item in vec { item.validate()? } }
		if let Some(ref val) = self.lndg_fee { val.validate()? }
		if let Some(ref val) = self.outsdng_mrgn_ln_amt { val.validate()? }
		if let Some(ref val) = self.shrt_mkt_val_amt { val.validate()? }
		if let Some(ref val) = self.lvl_tp { val.validate()? }
		if let Some(ref val) = self.unit_of_measr { val.validate()? }
		Ok(())
	}
}


// LocalInstrument2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LocalInstrument2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl LocalInstrument2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// LocalMarketAnnex6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LocalMarketAnnex6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctry") )]
	pub ctry: Vec<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LclOrdrDsk") )]
	pub lcl_ordr_dsk: OrderDesk1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SbcptPrcgChrtcs", skip_serializing_if = "Option::is_none") )]
	pub sbcpt_prcg_chrtcs: Option<ProcessingCharacteristics11>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RedPrcgChrtcs", skip_serializing_if = "Option::is_none") )]
	pub red_prcg_chrtcs: Option<ProcessingCharacteristics10>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SwtchPrcgChrtcs", skip_serializing_if = "Option::is_none") )]
	pub swtch_prcg_chrtcs: Option<ProcessingCharacteristics9>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshSttlmDtls", skip_serializing_if = "Option::is_none") )]
	pub csh_sttlm_dtls: Option<Vec<CashAccount205>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<Vec<AdditionalInformation15>>,
}

impl LocalMarketAnnex6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		for item in &self.ctry {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(&item) {
				return Err(ValidationError::new(1005, "ctry does not match the required pattern".to_string()));
			}
		}
		self.lcl_ordr_dsk.validate()?;
		if let Some(ref val) = self.sbcpt_prcg_chrtcs { val.validate()? }
		if let Some(ref val) = self.red_prcg_chrtcs { val.validate()? }
		if let Some(ref val) = self.swtch_prcg_chrtcs { val.validate()? }
		if let Some(ref vec) = self.csh_sttlm_dtls { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.addtl_inf { for item in vec { item.validate()? } }
		Ok(())
	}
}


// LockStatus1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum LockStatus1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "LOCK") )]
	CodeLOCK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ULCK") )]
	CodeULCK,
}

impl LockStatus1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// LongPaymentIdentification4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LongPaymentIdentification4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxId", skip_serializing_if = "Option::is_none") )]
	pub tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UETR", skip_serializing_if = "Option::is_none") )]
	pub uetr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBkSttlmAmt") )]
	pub intr_bk_sttlm_amt: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBkSttlmDt") )]
	pub intr_bk_sttlm_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtMtd", skip_serializing_if = "Option::is_none") )]
	pub pmt_mtd: Option<PaymentOrigin1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstgAgt") )]
	pub instg_agt: BranchAndFinancialInstitutionIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstdAgt") )]
	pub instd_agt: BranchAndFinancialInstitutionIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtryTp", skip_serializing_if = "Option::is_none") )]
	pub ntry_tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndToEndId", skip_serializing_if = "Option::is_none") )]
	pub end_to_end_id: Option<String>,
}

impl LongPaymentIdentification4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.uetr {
			let pattern = Regex::new("[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "uetr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.pmt_mtd { val.validate()? }
		self.instg_agt.validate()?;
		self.instd_agt.validate()?;
		if let Some(ref val) = self.ntry_tp {
			let pattern = Regex::new("[BEOVW]{1,1}[0-9]{2,2}|DUM").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ntry_tp does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.end_to_end_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "end_to_end_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "end_to_end_id exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// LongPostalAddress1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LongPostalAddress1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ustrd", skip_serializing_if = "Option::is_none") )]
	pub ustrd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Strd", skip_serializing_if = "Option::is_none") )]
	pub strd: Option<StructuredLongPostalAddress1>,
}

impl LongPostalAddress1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ustrd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ustrd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "ustrd exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.strd { val.validate()? }
		Ok(())
	}
}


// LossBearing2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct LossBearing2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NoCptlLoss", skip_serializing_if = "Option::is_none") )]
	pub no_cptl_loss: Option<TargetMarket1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LtdCptlLoss", skip_serializing_if = "Option::is_none") )]
	pub ltd_cptl_loss: Option<TargetMarket1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LtdCptlLossLvl", skip_serializing_if = "Option::is_none") )]
	pub ltd_cptl_loss_lvl: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NoCptlGrnt", skip_serializing_if = "Option::is_none") )]
	pub no_cptl_grnt: Option<TargetMarket1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LossByndCptl", skip_serializing_if = "Option::is_none") )]
	pub loss_bynd_cptl: Option<TargetMarket1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<Vec<OtherTargetMarketLossBearing1>>,
}

impl LossBearing2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.no_cptl_loss { val.validate()? }
		if let Some(ref val) = self.ltd_cptl_loss { val.validate()? }
		if let Some(ref val) = self.no_cptl_grnt { val.validate()? }
		if let Some(ref val) = self.loss_bynd_cptl { val.validate()? }
		if let Some(ref vec) = self.othr { for item in vec { item.validate()? } }
		Ok(())
	}
}


// MICEntityType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum MICEntityType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "APPA") )]
	CodeAPPA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CTPS") )]
	CodeCTPS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MLTF") )]
	CodeMLTF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTFS") )]
	CodeOTFS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RMKT") )]
	CodeRMKT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SINT") )]
	CodeSINT,
}

impl MICEntityType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// MailType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MailType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<MailType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl MailType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// MailType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum MailType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "AIRM") )]
	CodeAIRM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ORDM") )]
	CodeORDM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REGM") )]
	CodeREGM,
}

impl MailType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// MainFundOrderDeskLocation1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MainFundOrderDeskLocation1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctry") )]
	pub ctry: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TmZoneOffSet") )]
	pub tm_zone_off_set: UTCOffset1,
}

impl MainFundOrderDeskLocation1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{2,2}").unwrap();
		if !pattern.is_match(&self.ctry) {
			return Err(ValidationError::new(1005, "ctry does not match the required pattern".to_string()));
		}
		self.tm_zone_off_set.validate()?;
		Ok(())
	}
}


// Mandate20 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Mandate20 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MndtId") )]
	pub mndt_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MndtReqId", skip_serializing_if = "Option::is_none") )]
	pub mndt_req_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Authntcn", skip_serializing_if = "Option::is_none") )]
	pub authntcn: Option<MandateAuthentication1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<MandateTypeInformation2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ocrncs", skip_serializing_if = "Option::is_none") )]
	pub ocrncs: Option<MandateOccurrences5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrckgInd") )]
	pub trckg_ind: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrstColltnAmt", skip_serializing_if = "Option::is_none") )]
	pub frst_colltn_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ColltnAmt", skip_serializing_if = "Option::is_none") )]
	pub colltn_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MaxAmt", skip_serializing_if = "Option::is_none") )]
	pub max_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Adjstmnt", skip_serializing_if = "Option::is_none") )]
	pub adjstmnt: Option<MandateAdjustment1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<MandateSetupReason1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrSchmeId", skip_serializing_if = "Option::is_none") )]
	pub cdtr_schme_id: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cdtr") )]
	pub cdtr: PartyIdentification272,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAcct", skip_serializing_if = "Option::is_none") )]
	pub cdtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgt", skip_serializing_if = "Option::is_none") )]
	pub cdtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtCdtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_cdtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dbtr") )]
	pub dbtr: PartyIdentification272,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgt") )]
	pub dbtr_agt: BranchAndFinancialInstitutionIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtDbtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_dbtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MndtRef", skip_serializing_if = "Option::is_none") )]
	pub mndt_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RfrdDoc", skip_serializing_if = "Option::is_none") )]
	pub rfrd_doc: Option<Vec<ReferredMandateDocument2>>,
}

impl Mandate20 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.mndt_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "mndt_id is shorter than the minimum length of 1".to_string()));
		}
		if self.mndt_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "mndt_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.mndt_req_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mndt_req_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "mndt_req_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.authntcn { val.validate()? }
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.ocrncs { val.validate()? }
		if let Some(ref val) = self.frst_colltn_amt { val.validate()? }
		if let Some(ref val) = self.colltn_amt { val.validate()? }
		if let Some(ref val) = self.max_amt { val.validate()? }
		if let Some(ref val) = self.adjstmnt { val.validate()? }
		if let Some(ref val) = self.rsn { val.validate()? }
		if let Some(ref val) = self.cdtr_schme_id { val.validate()? }
		self.cdtr.validate()?;
		if let Some(ref val) = self.cdtr_acct { val.validate()? }
		if let Some(ref val) = self.cdtr_agt { val.validate()? }
		if let Some(ref val) = self.ultmt_cdtr { val.validate()? }
		self.dbtr.validate()?;
		if let Some(ref val) = self.dbtr_acct { val.validate()? }
		self.dbtr_agt.validate()?;
		if let Some(ref val) = self.ultmt_dbtr { val.validate()? }
		if let Some(ref val) = self.mndt_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mndt_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "mndt_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref vec) = self.rfrd_doc { for item in vec { item.validate()? } }
		Ok(())
	}
}


// Mandate21 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Mandate21 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MndtId") )]
	pub mndt_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MndtReqId", skip_serializing_if = "Option::is_none") )]
	pub mndt_req_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Authntcn", skip_serializing_if = "Option::is_none") )]
	pub authntcn: Option<MandateAuthentication1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<MandateTypeInformation2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ocrncs", skip_serializing_if = "Option::is_none") )]
	pub ocrncs: Option<MandateOccurrences5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrckgInd") )]
	pub trckg_ind: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrstColltnAmt", skip_serializing_if = "Option::is_none") )]
	pub frst_colltn_amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ColltnAmt", skip_serializing_if = "Option::is_none") )]
	pub colltn_amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MaxAmt", skip_serializing_if = "Option::is_none") )]
	pub max_amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Adjstmnt", skip_serializing_if = "Option::is_none") )]
	pub adjstmnt: Option<MandateAdjustment1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<MandateSetupReason1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrSchmeId", skip_serializing_if = "Option::is_none") )]
	pub cdtr_schme_id: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cdtr", skip_serializing_if = "Option::is_none") )]
	pub cdtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAcct", skip_serializing_if = "Option::is_none") )]
	pub cdtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgt", skip_serializing_if = "Option::is_none") )]
	pub cdtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtCdtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_cdtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dbtr", skip_serializing_if = "Option::is_none") )]
	pub dbtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgt", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtDbtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_dbtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MndtRef", skip_serializing_if = "Option::is_none") )]
	pub mndt_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RfrdDoc", skip_serializing_if = "Option::is_none") )]
	pub rfrd_doc: Option<Vec<ReferredMandateDocument2>>,
}

impl Mandate21 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.mndt_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "mndt_id is shorter than the minimum length of 1".to_string()));
		}
		if self.mndt_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "mndt_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.mndt_req_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mndt_req_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "mndt_req_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.authntcn { val.validate()? }
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.ocrncs { val.validate()? }
		if let Some(ref val) = self.frst_colltn_amt { val.validate()? }
		if let Some(ref val) = self.colltn_amt { val.validate()? }
		if let Some(ref val) = self.max_amt { val.validate()? }
		if let Some(ref val) = self.adjstmnt { val.validate()? }
		if let Some(ref val) = self.rsn { val.validate()? }
		if let Some(ref val) = self.cdtr_schme_id { val.validate()? }
		if let Some(ref val) = self.cdtr { val.validate()? }
		if let Some(ref val) = self.cdtr_acct { val.validate()? }
		if let Some(ref val) = self.cdtr_agt { val.validate()? }
		if let Some(ref val) = self.ultmt_cdtr { val.validate()? }
		if let Some(ref val) = self.dbtr { val.validate()? }
		if let Some(ref val) = self.dbtr_acct { val.validate()? }
		if let Some(ref val) = self.dbtr_agt { val.validate()? }
		if let Some(ref val) = self.ultmt_dbtr { val.validate()? }
		if let Some(ref val) = self.mndt_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mndt_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "mndt_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref vec) = self.rfrd_doc { for item in vec { item.validate()? } }
		Ok(())
	}
}


// Mandate22 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Mandate22 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MndtId", skip_serializing_if = "Option::is_none") )]
	pub mndt_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MndtReqId", skip_serializing_if = "Option::is_none") )]
	pub mndt_req_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Authntcn", skip_serializing_if = "Option::is_none") )]
	pub authntcn: Option<MandateAuthentication1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<MandateTypeInformation2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ocrncs", skip_serializing_if = "Option::is_none") )]
	pub ocrncs: Option<MandateOccurrences5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrckgInd") )]
	pub trckg_ind: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrstColltnAmt", skip_serializing_if = "Option::is_none") )]
	pub frst_colltn_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ColltnAmt", skip_serializing_if = "Option::is_none") )]
	pub colltn_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MaxAmt", skip_serializing_if = "Option::is_none") )]
	pub max_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Adjstmnt", skip_serializing_if = "Option::is_none") )]
	pub adjstmnt: Option<MandateAdjustment1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<MandateSetupReason1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrSchmeId", skip_serializing_if = "Option::is_none") )]
	pub cdtr_schme_id: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cdtr") )]
	pub cdtr: PartyIdentification272,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAcct", skip_serializing_if = "Option::is_none") )]
	pub cdtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgt", skip_serializing_if = "Option::is_none") )]
	pub cdtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtCdtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_cdtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dbtr") )]
	pub dbtr: PartyIdentification272,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgt") )]
	pub dbtr_agt: BranchAndFinancialInstitutionIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtDbtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_dbtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MndtRef", skip_serializing_if = "Option::is_none") )]
	pub mndt_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RfrdDoc", skip_serializing_if = "Option::is_none") )]
	pub rfrd_doc: Option<Vec<ReferredMandateDocument2>>,
}

impl Mandate22 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mndt_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mndt_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "mndt_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.mndt_req_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mndt_req_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "mndt_req_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.authntcn { val.validate()? }
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.ocrncs { val.validate()? }
		if let Some(ref val) = self.frst_colltn_amt { val.validate()? }
		if let Some(ref val) = self.colltn_amt { val.validate()? }
		if let Some(ref val) = self.max_amt { val.validate()? }
		if let Some(ref val) = self.adjstmnt { val.validate()? }
		if let Some(ref val) = self.rsn { val.validate()? }
		if let Some(ref val) = self.cdtr_schme_id { val.validate()? }
		self.cdtr.validate()?;
		if let Some(ref val) = self.cdtr_acct { val.validate()? }
		if let Some(ref val) = self.cdtr_agt { val.validate()? }
		if let Some(ref val) = self.ultmt_cdtr { val.validate()? }
		self.dbtr.validate()?;
		if let Some(ref val) = self.dbtr_acct { val.validate()? }
		self.dbtr_agt.validate()?;
		if let Some(ref val) = self.ultmt_dbtr { val.validate()? }
		if let Some(ref val) = self.mndt_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mndt_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "mndt_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref vec) = self.rfrd_doc { for item in vec { item.validate()? } }
		Ok(())
	}
}


// Mandate23 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Mandate23 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MndtId", skip_serializing_if = "Option::is_none") )]
	pub mndt_id: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MndtReqId") )]
	pub mndt_req_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Authntcn", skip_serializing_if = "Option::is_none") )]
	pub authntcn: Option<MandateAuthentication1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<MandateTypeInformation2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ocrncs", skip_serializing_if = "Option::is_none") )]
	pub ocrncs: Option<MandateOccurrences5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrckgInd") )]
	pub trckg_ind: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrstColltnAmt", skip_serializing_if = "Option::is_none") )]
	pub frst_colltn_amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ColltnAmt", skip_serializing_if = "Option::is_none") )]
	pub colltn_amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MaxAmt", skip_serializing_if = "Option::is_none") )]
	pub max_amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Adjstmnt", skip_serializing_if = "Option::is_none") )]
	pub adjstmnt: Option<MandateAdjustment1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<MandateSetupReason1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrSchmeId", skip_serializing_if = "Option::is_none") )]
	pub cdtr_schme_id: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cdtr") )]
	pub cdtr: PartyIdentification272,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAcct", skip_serializing_if = "Option::is_none") )]
	pub cdtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgt", skip_serializing_if = "Option::is_none") )]
	pub cdtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtCdtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_cdtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dbtr") )]
	pub dbtr: PartyIdentification272,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgt") )]
	pub dbtr_agt: BranchAndFinancialInstitutionIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtDbtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_dbtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MndtRef", skip_serializing_if = "Option::is_none") )]
	pub mndt_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RfrdDoc", skip_serializing_if = "Option::is_none") )]
	pub rfrd_doc: Option<Vec<ReferredMandateDocument2>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl Mandate23 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.mndt_id {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "mndt_id is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 35 {
					return Err(ValidationError::new(1002, "mndt_id exceeds the maximum length of 35".to_string()));
				}
			}
		}
		if self.mndt_req_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "mndt_req_id is shorter than the minimum length of 1".to_string()));
		}
		if self.mndt_req_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "mndt_req_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.authntcn { val.validate()? }
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.ocrncs { val.validate()? }
		if let Some(ref val) = self.frst_colltn_amt { val.validate()? }
		if let Some(ref val) = self.colltn_amt { val.validate()? }
		if let Some(ref val) = self.max_amt { val.validate()? }
		if let Some(ref val) = self.adjstmnt { val.validate()? }
		if let Some(ref val) = self.rsn { val.validate()? }
		if let Some(ref val) = self.cdtr_schme_id { val.validate()? }
		self.cdtr.validate()?;
		if let Some(ref val) = self.cdtr_acct { val.validate()? }
		if let Some(ref val) = self.cdtr_agt { val.validate()? }
		if let Some(ref val) = self.ultmt_cdtr { val.validate()? }
		self.dbtr.validate()?;
		if let Some(ref val) = self.dbtr_acct { val.validate()? }
		self.dbtr_agt.validate()?;
		if let Some(ref val) = self.ultmt_dbtr { val.validate()? }
		if let Some(ref val) = self.mndt_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mndt_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "mndt_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref vec) = self.rfrd_doc { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// MandateAcceptance8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MandateAcceptance8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMsgInf", skip_serializing_if = "Option::is_none") )]
	pub orgnl_msg_inf: Option<OriginalMessageInformation1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AccptncRslt") )]
	pub accptnc_rslt: AcceptanceResult6,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMndt", skip_serializing_if = "Option::is_none") )]
	pub orgnl_mndt: Option<OriginalMandate11Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl MandateAcceptance8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgnl_msg_inf { val.validate()? }
		self.accptnc_rslt.validate()?;
		if let Some(ref val) = self.orgnl_mndt { val.validate()? }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// MandateAdjustment1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MandateAdjustment1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtAdjstmntRuleInd") )]
	pub dt_adjstmnt_rule_ind: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctgy", skip_serializing_if = "Option::is_none") )]
	pub ctgy: Option<Frequency37Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rate", skip_serializing_if = "Option::is_none") )]
	pub rate: Option<f64>,
}

impl MandateAdjustment1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ctgy { val.validate()? }
		if let Some(ref val) = self.amt { val.validate()? }
		Ok(())
	}
}


// MandateAmendment8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MandateAmendment8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMsgInf", skip_serializing_if = "Option::is_none") )]
	pub orgnl_msg_inf: Option<OriginalMessageInformation1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AmdmntRsn") )]
	pub amdmnt_rsn: MandateAmendmentReason3,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mndt") )]
	pub mndt: Mandate21,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMndt") )]
	pub orgnl_mndt: OriginalMandate10Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl MandateAmendment8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgnl_msg_inf { val.validate()? }
		self.amdmnt_rsn.validate()?;
		self.mndt.validate()?;
		self.orgnl_mndt.validate()?;
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// MandateAmendmentReason3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MandateAmendmentReason3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Orgtr", skip_serializing_if = "Option::is_none") )]
	pub orgtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn") )]
	pub rsn: MandateReason1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<Vec<String>>,
}

impl MandateAmendmentReason3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgtr { val.validate()? }
		self.rsn.validate()?;
		if let Some(ref vec) = self.addtl_inf {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 105 {
					return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 105".to_string()));
				}
			}
		}
		Ok(())
	}
}


// MandateAuthentication1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MandateAuthentication1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgAuthntcnCd", skip_serializing_if = "Option::is_none") )]
	pub msg_authntcn_cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dt", skip_serializing_if = "Option::is_none") )]
	pub dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Chanl", skip_serializing_if = "Option::is_none") )]
	pub chanl: Option<AuthenticationChannel1Choice>,
}

impl MandateAuthentication1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.msg_authntcn_cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "msg_authntcn_cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 16 {
				return Err(ValidationError::new(1002, "msg_authntcn_cd exceeds the maximum length of 16".to_string()));
			}
		}
		if let Some(ref val) = self.chanl { val.validate()? }
		Ok(())
	}
}


// MandateCancellation8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MandateCancellation8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMsgInf", skip_serializing_if = "Option::is_none") )]
	pub orgnl_msg_inf: Option<OriginalMessageInformation1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CxlRsn") )]
	pub cxl_rsn: MandateCancellationReason2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMndt") )]
	pub orgnl_mndt: OriginalMandate10Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl MandateCancellation8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgnl_msg_inf { val.validate()? }
		self.cxl_rsn.validate()?;
		self.orgnl_mndt.validate()?;
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// MandateCancellationReason2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MandateCancellationReason2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Orgtr", skip_serializing_if = "Option::is_none") )]
	pub orgtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn") )]
	pub rsn: MandateReason1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<Vec<String>>,
}

impl MandateCancellationReason2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgtr { val.validate()? }
		self.rsn.validate()?;
		if let Some(ref vec) = self.addtl_inf {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 105 {
					return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 105".to_string()));
				}
			}
		}
		Ok(())
	}
}


// MandateClassification1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MandateClassification1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<MandateClassification1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl MandateClassification1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// MandateClassification1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum MandateClassification1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "FIXE") )]
	CodeFIXE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "USGB") )]
	CodeUSGB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VARI") )]
	CodeVARI,
}

impl MandateClassification1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// MandateCopy4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MandateCopy4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMsgInf", skip_serializing_if = "Option::is_none") )]
	pub orgnl_msg_inf: Option<OriginalMessageInformation1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMndt") )]
	pub orgnl_mndt: OriginalMandate10Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MndtSts", skip_serializing_if = "Option::is_none") )]
	pub mndt_sts: Option<MandateStatus1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl MandateCopy4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgnl_msg_inf { val.validate()? }
		self.orgnl_mndt.validate()?;
		if let Some(ref val) = self.mndt_sts { val.validate()? }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// MandateOccurrences5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MandateOccurrences5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SeqTp") )]
	pub seq_tp: SequenceType2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Frqcy", skip_serializing_if = "Option::is_none") )]
	pub frqcy: Option<Frequency36Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Drtn", skip_serializing_if = "Option::is_none") )]
	pub drtn: Option<DatePeriod3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrstColltnDt", skip_serializing_if = "Option::is_none") )]
	pub frst_colltn_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FnlColltnDt", skip_serializing_if = "Option::is_none") )]
	pub fnl_colltn_dt: Option<String>,
}

impl MandateOccurrences5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.seq_tp.validate()?;
		if let Some(ref val) = self.frqcy { val.validate()? }
		if let Some(ref val) = self.drtn { val.validate()? }
		Ok(())
	}
}


// MandateReason1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MandateReason1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl MandateReason1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// MandateRelatedData2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MandateRelatedData2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DrctDbtMndt", skip_serializing_if = "Option::is_none") )]
	pub drct_dbt_mndt: Option<MandateRelatedInformation15>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtTrfMndt", skip_serializing_if = "Option::is_none") )]
	pub cdt_trf_mndt: Option<CreditTransferMandateData1>,
}

impl MandateRelatedData2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.drct_dbt_mndt { val.validate()? }
		if let Some(ref val) = self.cdt_trf_mndt { val.validate()? }
		Ok(())
	}
}


// MandateRelatedData3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MandateRelatedData3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DrctDbtMndt", skip_serializing_if = "Option::is_none") )]
	pub drct_dbt_mndt: Option<MandateRelatedInformation16>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtTrfMndt", skip_serializing_if = "Option::is_none") )]
	pub cdt_trf_mndt: Option<CreditTransferMandateData1>,
}

impl MandateRelatedData3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.drct_dbt_mndt { val.validate()? }
		if let Some(ref val) = self.cdt_trf_mndt { val.validate()? }
		Ok(())
	}
}


// MandateRelatedInformation15 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MandateRelatedInformation15 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MndtId", skip_serializing_if = "Option::is_none") )]
	pub mndt_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtOfSgntr", skip_serializing_if = "Option::is_none") )]
	pub dt_of_sgntr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AmdmntInd", skip_serializing_if = "Option::is_none") )]
	pub amdmnt_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AmdmntInfDtls", skip_serializing_if = "Option::is_none") )]
	pub amdmnt_inf_dtls: Option<AmendmentInformationDetails14>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ElctrncSgntr", skip_serializing_if = "Option::is_none") )]
	pub elctrnc_sgntr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrstColltnDt", skip_serializing_if = "Option::is_none") )]
	pub frst_colltn_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FnlColltnDt", skip_serializing_if = "Option::is_none") )]
	pub fnl_colltn_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Frqcy", skip_serializing_if = "Option::is_none") )]
	pub frqcy: Option<Frequency36Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<MandateSetupReason1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrckgDays", skip_serializing_if = "Option::is_none") )]
	pub trckg_days: Option<String>,
}

impl MandateRelatedInformation15 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mndt_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mndt_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "mndt_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.amdmnt_inf_dtls { val.validate()? }
		if let Some(ref val) = self.elctrnc_sgntr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "elctrnc_sgntr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 1025 {
				return Err(ValidationError::new(1002, "elctrnc_sgntr exceeds the maximum length of 1025".to_string()));
			}
		}
		if let Some(ref val) = self.frqcy { val.validate()? }
		if let Some(ref val) = self.rsn { val.validate()? }
		if let Some(ref val) = self.trckg_days {
			let pattern = Regex::new("[0-9]{2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "trckg_days does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// MandateRelatedInformation16 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MandateRelatedInformation16 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MndtId", skip_serializing_if = "Option::is_none") )]
	pub mndt_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtOfSgntr", skip_serializing_if = "Option::is_none") )]
	pub dt_of_sgntr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AmdmntInd", skip_serializing_if = "Option::is_none") )]
	pub amdmnt_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AmdmntInfDtls", skip_serializing_if = "Option::is_none") )]
	pub amdmnt_inf_dtls: Option<AmendmentInformationDetails15>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ElctrncSgntr", skip_serializing_if = "Option::is_none") )]
	pub elctrnc_sgntr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrstColltnDt", skip_serializing_if = "Option::is_none") )]
	pub frst_colltn_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FnlColltnDt", skip_serializing_if = "Option::is_none") )]
	pub fnl_colltn_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Frqcy", skip_serializing_if = "Option::is_none") )]
	pub frqcy: Option<Frequency36Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<MandateSetupReason1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrckgDays", skip_serializing_if = "Option::is_none") )]
	pub trckg_days: Option<String>,
}

impl MandateRelatedInformation16 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mndt_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mndt_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "mndt_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.amdmnt_inf_dtls { val.validate()? }
		if let Some(ref val) = self.elctrnc_sgntr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "elctrnc_sgntr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 1025 {
				return Err(ValidationError::new(1002, "elctrnc_sgntr exceeds the maximum length of 1025".to_string()));
			}
		}
		if let Some(ref val) = self.frqcy { val.validate()? }
		if let Some(ref val) = self.rsn { val.validate()? }
		if let Some(ref val) = self.trckg_days {
			let pattern = Regex::new("[0-9]{2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "trckg_days does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// MandateSetupReason1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MandateSetupReason1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl MandateSetupReason1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 70".to_string()));
			}
		}
		Ok(())
	}
}


// MandateStatus1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MandateStatus1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl MandateStatus1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// MandateSuspension4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MandateSuspension4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SspnsnReqId") )]
	pub sspnsn_req_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMsgInf", skip_serializing_if = "Option::is_none") )]
	pub orgnl_msg_inf: Option<OriginalMessageInformation1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SspnsnRsn") )]
	pub sspnsn_rsn: MandateSuspensionReason3,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMndt") )]
	pub orgnl_mndt: OriginalMandate10Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl MandateSuspension4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.sspnsn_req_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "sspnsn_req_id is shorter than the minimum length of 1".to_string()));
		}
		if self.sspnsn_req_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "sspnsn_req_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.orgnl_msg_inf { val.validate()? }
		self.sspnsn_rsn.validate()?;
		self.orgnl_mndt.validate()?;
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// MandateSuspensionReason1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MandateSuspensionReason1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl MandateSuspensionReason1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// MandateSuspensionReason3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MandateSuspensionReason3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Orgtr", skip_serializing_if = "Option::is_none") )]
	pub orgtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn") )]
	pub rsn: MandateSuspensionReason1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<Vec<String>>,
}

impl MandateSuspensionReason3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgtr { val.validate()? }
		self.rsn.validate()?;
		if let Some(ref vec) = self.addtl_inf {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 105 {
					return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 105".to_string()));
				}
			}
		}
		Ok(())
	}
}


// MandateTypeInformation2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MandateTypeInformation2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SvcLvl", skip_serializing_if = "Option::is_none") )]
	pub svc_lvl: Option<ServiceLevel8Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LclInstrm", skip_serializing_if = "Option::is_none") )]
	pub lcl_instrm: Option<LocalInstrument2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtgyPurp", skip_serializing_if = "Option::is_none") )]
	pub ctgy_purp: Option<CategoryPurpose1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Clssfctn", skip_serializing_if = "Option::is_none") )]
	pub clssfctn: Option<MandateClassification1Choice>,
}

impl MandateTypeInformation2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.svc_lvl { val.validate()? }
		if let Some(ref val) = self.lcl_instrm { val.validate()? }
		if let Some(ref val) = self.ctgy_purp { val.validate()? }
		if let Some(ref val) = self.clssfctn { val.validate()? }
		Ok(())
	}
}


// ManifestData2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ManifestData2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DocTp") )]
	pub doc_tp: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfDocs") )]
	pub nb_of_docs: f64,
}

impl ManifestData2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.doc_tp.chars().count() < 1 {
			return Err(ValidationError::new(1001, "doc_tp is shorter than the minimum length of 1".to_string()));
		}
		if self.doc_tp.chars().count() > 35 {
			return Err(ValidationError::new(1002, "doc_tp exceeds the maximum length of 35".to_string()));
		}
		Ok(())
	}
}


// MarginAccount1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MarginAccount1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: PartyIdentification118Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PosAcct") )]
	pub pos_acct: Vec<PositionAccount1>,
}

impl MarginAccount1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.id.validate()?;
		for item in &self.pos_acct { item.validate()? }
		Ok(())
	}
}


// MarginCollateralReport4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MarginCollateralReport4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollPrtflCd") )]
	pub coll_prtfl_cd: CollateralPortfolioCode5Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollstnCtgy") )]
	pub collstn_ctgy: CollateralisationType3Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TmStmp", skip_serializing_if = "Option::is_none") )]
	pub tm_stmp: Option<String>,
}

impl MarginCollateralReport4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.coll_prtfl_cd.validate()?;
		self.collstn_ctgy.validate()?;
		Ok(())
	}
}


// MarginCollateralReport5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MarginCollateralReport5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollPrtflCd") )]
	pub coll_prtfl_cd: CollateralPortfolioCode6Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollstnCtgy") )]
	pub collstn_ctgy: CollateralisationType3Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TmStmp", skip_serializing_if = "Option::is_none") )]
	pub tm_stmp: Option<String>,
}

impl MarginCollateralReport5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.coll_prtfl_cd.validate()?;
		self.collstn_ctgy.validate()?;
		Ok(())
	}
}


// MarginPortfolio3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MarginPortfolio3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitlMrgnPrtflCd") )]
	pub initl_mrgn_prtfl_cd: PortfolioCode5Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VartnMrgnPrtflCd", skip_serializing_if = "Option::is_none") )]
	pub vartn_mrgn_prtfl_cd: Option<PortfolioCode5Choice>,
}

impl MarginPortfolio3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.initl_mrgn_prtfl_cd.validate()?;
		if let Some(ref val) = self.vartn_mrgn_prtfl_cd { val.validate()? }
		Ok(())
	}
}


// MarginPortfolio4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MarginPortfolio4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitlMrgnPrtflCd", skip_serializing_if = "Option::is_none") )]
	pub initl_mrgn_prtfl_cd: Option<PortfolioCode5Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VartnMrgnPrtflCd", skip_serializing_if = "Option::is_none") )]
	pub vartn_mrgn_prtfl_cd: Option<PortfolioCode5Choice>,
}

impl MarginPortfolio4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.initl_mrgn_prtfl_cd { val.validate()? }
		if let Some(ref val) = self.vartn_mrgn_prtfl_cd { val.validate()? }
		Ok(())
	}
}


// MarginReportData10 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MarginReportData10 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgTmStmp", skip_serializing_if = "Option::is_none") )]
	pub rptg_tm_stmp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtyId") )]
	pub ctr_pty_id: TradeCounterpartyReport20,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EvtDt", skip_serializing_if = "Option::is_none") )]
	pub evt_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxId", skip_serializing_if = "Option::is_none") )]
	pub tx_id: Option<UniqueTransactionIdentifier2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Coll") )]
	pub coll: MarginCollateralReport5,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstdMrgnOrColl", skip_serializing_if = "Option::is_none") )]
	pub pstd_mrgn_or_coll: Option<PostedMarginOrCollateral6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RcvdMrgnOrColl", skip_serializing_if = "Option::is_none") )]
	pub rcvd_mrgn_or_coll: Option<ReceivedMarginOrCollateral6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtyRatgTrggrInd", skip_serializing_if = "Option::is_none") )]
	pub ctr_pty_ratg_trggr_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtyRatgThrshldInd", skip_serializing_if = "Option::is_none") )]
	pub ctr_pty_ratg_thrshld_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctMod", skip_serializing_if = "Option::is_none") )]
	pub ctrct_mod: Option<ContractModification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechAttrbts", skip_serializing_if = "Option::is_none") )]
	pub tech_attrbts: Option<TechnicalAttributes6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl MarginReportData10 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.ctr_pty_id.validate()?;
		if let Some(ref val) = self.tx_id { val.validate()? }
		self.coll.validate()?;
		if let Some(ref val) = self.pstd_mrgn_or_coll { val.validate()? }
		if let Some(ref val) = self.rcvd_mrgn_or_coll { val.validate()? }
		if let Some(ref val) = self.ctrct_mod { val.validate()? }
		if let Some(ref val) = self.tech_attrbts { val.validate()? }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// MarginReportData9 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MarginReportData9 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgTmStmp", skip_serializing_if = "Option::is_none") )]
	pub rptg_tm_stmp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtyId") )]
	pub ctr_pty_id: TradeCounterpartyReport20,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EvtDt", skip_serializing_if = "Option::is_none") )]
	pub evt_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxId", skip_serializing_if = "Option::is_none") )]
	pub tx_id: Option<UniqueTransactionIdentifier2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Coll") )]
	pub coll: MarginCollateralReport5,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstdMrgnOrColl", skip_serializing_if = "Option::is_none") )]
	pub pstd_mrgn_or_coll: Option<PostedMarginOrCollateral6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RcvdMrgnOrColl", skip_serializing_if = "Option::is_none") )]
	pub rcvd_mrgn_or_coll: Option<ReceivedMarginOrCollateral6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtyRatgTrggrInd", skip_serializing_if = "Option::is_none") )]
	pub ctr_pty_ratg_trggr_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtyRatgThrshldInd", skip_serializing_if = "Option::is_none") )]
	pub ctr_pty_ratg_thrshld_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechAttrbts", skip_serializing_if = "Option::is_none") )]
	pub tech_attrbts: Option<TechnicalAttributes6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl MarginReportData9 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.ctr_pty_id.validate()?;
		if let Some(ref val) = self.tx_id { val.validate()? }
		self.coll.validate()?;
		if let Some(ref val) = self.pstd_mrgn_or_coll { val.validate()? }
		if let Some(ref val) = self.rcvd_mrgn_or_coll { val.validate()? }
		if let Some(ref val) = self.tech_attrbts { val.validate()? }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// MarginType2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MarginType2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<MarginType2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification36>,
}

impl MarginType2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// MarginType2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum MarginType2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ADFM") )]
	CodeADFM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "COMA") )]
	CodeCOMA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CEMA") )]
	CodeCEMA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SEMA") )]
	CodeSEMA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SCMA") )]
	CodeSCMA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UFMA") )]
	CodeUFMA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MARM") )]
	CodeMARM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SORM") )]
	CodeSORM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WWRM") )]
	CodeWWRM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BARM") )]
	CodeBARM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LIRM") )]
	CodeLIRM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CRAM") )]
	CodeCRAM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CVMA") )]
	CodeCVMA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SPMA") )]
	CodeSPMA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "JTDR") )]
	CodeJTDR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DRAO") )]
	CodeDRAO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
}

impl MarginType2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// MarketDetail2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MarketDetail2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AvrgDalyNbOfTxs", skip_serializing_if = "Option::is_none") )]
	pub avrg_daly_nb_of_txs: Option<f64>,
}

impl MarketDetail2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
		if !pattern.is_match(&self.id) {
			return Err(ValidationError::new(1005, "id does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// MarketIdentification1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum MarketIdentification1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "SGMT") )]
	CodeSGMT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OPRT") )]
	CodeOPRT,
}

impl MarketIdentification1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// MarketIdentification87 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MarketIdentification87 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctry") )]
	pub ctry: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClssfctnTp") )]
	pub clssfctn_tp: ClassificationType1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmPurp", skip_serializing_if = "Option::is_none") )]
	pub sttlm_purp: Option<Purpose3Choice>,
}

impl MarketIdentification87 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{2,2}").unwrap();
		if !pattern.is_match(&self.ctry) {
			return Err(ValidationError::new(1005, "ctry does not match the required pattern".to_string()));
		}
		self.clssfctn_tp.validate()?;
		if let Some(ref val) = self.sttlm_purp { val.validate()? }
		Ok(())
	}
}


// MarketIdentification95 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MarketIdentification95 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Oprg") )]
	pub oprg: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sgmt") )]
	pub sgmt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: MarketIdentification1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctgy", skip_serializing_if = "Option::is_none") )]
	pub ctgy: Option<MICEntityType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstnNm") )]
	pub instn_nm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Acrnm", skip_serializing_if = "Option::is_none") )]
	pub acrnm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "City", skip_serializing_if = "Option::is_none") )]
	pub city: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctry") )]
	pub ctry: CountryCodeAndName3,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AuthrtyNm", skip_serializing_if = "Option::is_none") )]
	pub authrty_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WebSite", skip_serializing_if = "Option::is_none") )]
	pub web_site: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Note", skip_serializing_if = "Option::is_none") )]
	pub note: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mod", skip_serializing_if = "Option::is_none") )]
	pub mod_attr: Option<Modification1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDt", skip_serializing_if = "Option::is_none") )]
	pub cre_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldtyPrd") )]
	pub vldty_prd: Period4Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsDt", skip_serializing_if = "Option::is_none") )]
	pub sts_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LastUpdtdDt", skip_serializing_if = "Option::is_none") )]
	pub last_updtd_dt: Option<String>,
}

impl MarketIdentification95 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
		if !pattern.is_match(&self.oprg) {
			return Err(ValidationError::new(1005, "oprg does not match the required pattern".to_string()));
		}
		let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
		if !pattern.is_match(&self.sgmt) {
			return Err(ValidationError::new(1005, "sgmt does not match the required pattern".to_string()));
		}
		self.tp.validate()?;
		if let Some(ref val) = self.ctgy { val.validate()? }
		if self.instn_nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "instn_nm is shorter than the minimum length of 1".to_string()));
		}
		if self.instn_nm.chars().count() > 450 {
			return Err(ValidationError::new(1002, "instn_nm exceeds the maximum length of 450".to_string()));
		}
		if let Some(ref val) = self.acrnm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acrnm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acrnm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.city {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "city is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "city exceeds the maximum length of 35".to_string()));
			}
		}
		self.ctry.validate()?;
		if let Some(ref val) = self.authrty_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "authrty_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 450 {
				return Err(ValidationError::new(1002, "authrty_nm exceeds the maximum length of 450".to_string()));
			}
		}
		if let Some(ref val) = self.web_site {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "web_site is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 210 {
				return Err(ValidationError::new(1002, "web_site exceeds the maximum length of 210".to_string()));
			}
		}
		if let Some(ref val) = self.note {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "note is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 450 {
				return Err(ValidationError::new(1002, "note exceeds the maximum length of 450".to_string()));
			}
		}
		if let Some(ref val) = self.mod_attr { val.validate()? }
		self.vldty_prd.validate()?;
		Ok(())
	}
}


// MarketIdentificationOrCashPurpose1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MarketIdentificationOrCashPurpose1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmInstrMktId", skip_serializing_if = "Option::is_none") )]
	pub sttlm_instr_mkt_id: Option<MarketIdentification87>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshSSIPurp", skip_serializing_if = "Option::is_none") )]
	pub csh_ssi_purp: Option<Vec<String>>,
}

impl MarketIdentificationOrCashPurpose1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.sttlm_instr_mkt_id { val.validate()? }
		if let Some(ref vec) = self.csh_ssi_purp {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "csh_ssi_purp is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 4 {
					return Err(ValidationError::new(1002, "csh_ssi_purp exceeds the maximum length of 4".to_string()));
				}
			}
		}
		Ok(())
	}
}


// MarketInfrastructureIdentification1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MarketInfrastructureIdentification1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl MarketInfrastructureIdentification1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 3 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 3".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// MarketMakerProfile2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MarketMakerProfile2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctPrd", skip_serializing_if = "Option::is_none") )]
	pub ctrct_prd: Option<DateTimePeriod2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cmplc", skip_serializing_if = "Option::is_none") )]
	pub cmplc: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MaxSprd", skip_serializing_if = "Option::is_none") )]
	pub max_sprd: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dscnt", skip_serializing_if = "Option::is_none") )]
	pub dscnt: Option<f64>,
}

impl MarketMakerProfile2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ctrct_prd { val.validate()? }
		Ok(())
	}
}


// MarketPracticeVersion1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MarketPracticeVersion1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm") )]
	pub nm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dt", skip_serializing_if = "Option::is_none") )]
	pub dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nb", skip_serializing_if = "Option::is_none") )]
	pub nb: Option<String>,
}

impl MarketPracticeVersion1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
		}
		if self.nm.chars().count() > 35 {
			return Err(ValidationError::new(1002, "nm exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "nb exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// MarketSpecificAttribute1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MarketSpecificAttribute1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm") )]
	pub nm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val") )]
	pub val: String,
}

impl MarketSpecificAttribute1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
		}
		if self.nm.chars().count() > 35 {
			return Err(ValidationError::new(1002, "nm exceeds the maximum length of 35".to_string()));
		}
		if self.val.chars().count() < 1 {
			return Err(ValidationError::new(1001, "val is shorter than the minimum length of 1".to_string()));
		}
		if self.val.chars().count() > 350 {
			return Err(ValidationError::new(1002, "val exceeds the maximum length of 350".to_string()));
		}
		Ok(())
	}
}


// MasterAgreement7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MasterAgreement7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: AgreementType2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Vrsn", skip_serializing_if = "Option::is_none") )]
	pub vrsn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrMstrAgrmtDtls", skip_serializing_if = "Option::is_none") )]
	pub othr_mstr_agrmt_dtls: Option<String>,
}

impl MasterAgreement7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tp.validate()?;
		if let Some(ref val) = self.vrsn {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "vrsn is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 50 {
				return Err(ValidationError::new(1002, "vrsn exceeds the maximum length of 50".to_string()));
			}
		}
		if let Some(ref val) = self.othr_mstr_agrmt_dtls {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "othr_mstr_agrmt_dtls is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "othr_mstr_agrmt_dtls exceeds the maximum length of 350".to_string()));
			}
		}
		Ok(())
	}
}


// MasterAgreement8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MasterAgreement8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<AgreementType2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Vrsn", skip_serializing_if = "Option::is_none") )]
	pub vrsn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrMstrAgrmtDtls", skip_serializing_if = "Option::is_none") )]
	pub othr_mstr_agrmt_dtls: Option<String>,
}

impl MasterAgreement8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.vrsn {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "vrsn is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 50 {
				return Err(ValidationError::new(1002, "vrsn exceeds the maximum length of 50".to_string()));
			}
		}
		if let Some(ref val) = self.othr_mstr_agrmt_dtls {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "othr_mstr_agrmt_dtls is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "othr_mstr_agrmt_dtls exceeds the maximum length of 350".to_string()));
			}
		}
		Ok(())
	}
}


// MatchingCriteria10 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MatchingCriteria10 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtyMtchgCrit", skip_serializing_if = "Option::is_none") )]
	pub ctr_pty_mtchg_crit: Option<CounterpartyMatchingCriteria4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LnMtchgCrit", skip_serializing_if = "Option::is_none") )]
	pub ln_mtchg_crit: Option<LoanMatchingCriteria9>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollMtchgCrit", skip_serializing_if = "Option::is_none") )]
	pub coll_mtchg_crit: Option<CollateralMatchingCriteria6>,
}

impl MatchingCriteria10 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ctr_pty_mtchg_crit { val.validate()? }
		if let Some(ref val) = self.ln_mtchg_crit { val.validate()? }
		if let Some(ref val) = self.coll_mtchg_crit { val.validate()? }
		Ok(())
	}
}


// MatchingCriteria17 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MatchingCriteria17 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtyMtchgCrit", skip_serializing_if = "Option::is_none") )]
	pub ctr_pty_mtchg_crit: Option<CounterpartyMatchingCriteria6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValtnMtchgCrit", skip_serializing_if = "Option::is_none") )]
	pub valtn_mtchg_crit: Option<ValuationMatchingCriteria1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctMtchgCrit", skip_serializing_if = "Option::is_none") )]
	pub ctrct_mtchg_crit: Option<ContractMatchingCriteria3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxMtchgCrit", skip_serializing_if = "Option::is_none") )]
	pub tx_mtchg_crit: Option<TransactionMatchingCriteria7>,
}

impl MatchingCriteria17 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ctr_pty_mtchg_crit { val.validate()? }
		if let Some(ref val) = self.valtn_mtchg_crit { val.validate()? }
		if let Some(ref val) = self.ctrct_mtchg_crit { val.validate()? }
		if let Some(ref val) = self.tx_mtchg_crit { val.validate()? }
		Ok(())
	}
}


// MaturityRedemptionType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum MaturityRedemptionType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "FRED") )]
	CodeFRED,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRNR") )]
	CodePRNR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRWR") )]
	CodePRWR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RNDM") )]
	CodeRNDM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRRA") )]
	CodePRRA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CALL") )]
	CodeCALL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PUUT") )]
	CodePUUT,
}

impl MaturityRedemptionType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// MaturityRedemptionType3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MaturityRedemptionType3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<MaturityRedemptionType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl MaturityRedemptionType3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// MaturityTerm2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MaturityTerm2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Unit") )]
	pub unit: RateBasis1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val") )]
	pub val: f64,
}

impl MaturityTerm2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.unit.validate()?;
		Ok(())
	}
}


// MaximumAmountByPeriod1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MaximumAmountByPeriod1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MaxAmt") )]
	pub max_amt: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfDays") )]
	pub nb_of_days: String,
}

impl MaximumAmountByPeriod1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.max_amt.validate()?;
		let pattern = Regex::new("[0-9]{1,3}").unwrap();
		if !pattern.is_match(&self.nb_of_days) {
			return Err(ValidationError::new(1005, "nb_of_days does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// Member6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Member6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MmbRtrAdr", skip_serializing_if = "Option::is_none") )]
	pub mmb_rtr_adr: Option<Vec<MemberIdentification3Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtctRef", skip_serializing_if = "Option::is_none") )]
	pub ctct_ref: Option<Vec<ContactIdentificationAndAddress1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ComAdr", skip_serializing_if = "Option::is_none") )]
	pub com_adr: Option<CommunicationAddress8>,
}

impl Member6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.mmb_rtr_adr { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.ctct_ref { for item in vec { item.validate()? } }
		if let Some(ref val) = self.com_adr { val.validate()? }
		Ok(())
	}
}


// Member7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Member7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RtrAdr", skip_serializing_if = "Option::is_none") )]
	pub rtr_adr: Option<Vec<MemberIdentification3Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Acct", skip_serializing_if = "Option::is_none") )]
	pub acct: Option<Vec<CashAccount40>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<SystemMemberType1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts", skip_serializing_if = "Option::is_none") )]
	pub sts: Option<SystemMemberStatus1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtctRef", skip_serializing_if = "Option::is_none") )]
	pub ctct_ref: Option<Vec<ContactIdentificationAndAddress2>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ComAdr", skip_serializing_if = "Option::is_none") )]
	pub com_adr: Option<CommunicationAddress10>,
}

impl Member7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref vec) = self.rtr_adr { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.acct { for item in vec { item.validate()? } }
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.sts { val.validate()? }
		if let Some(ref vec) = self.ctct_ref { for item in vec { item.validate()? } }
		if let Some(ref val) = self.com_adr { val.validate()? }
		Ok(())
	}
}


// MemberCriteria4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MemberCriteria4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NewQryNm", skip_serializing_if = "Option::is_none") )]
	pub new_qry_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SchCrit", skip_serializing_if = "Option::is_none") )]
	pub sch_crit: Option<Vec<MemberSearchCriteria4>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RtrCrit", skip_serializing_if = "Option::is_none") )]
	pub rtr_crit: Option<MemberReturnCriteria1>,
}

impl MemberCriteria4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.new_qry_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "new_qry_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "new_qry_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref vec) = self.sch_crit { for item in vec { item.validate()? } }
		if let Some(ref val) = self.rtr_crit { val.validate()? }
		Ok(())
	}
}


// MemberCriteriaDefinition2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MemberCriteriaDefinition2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "QryNm", skip_serializing_if = "Option::is_none") )]
	pub qry_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NewCrit", skip_serializing_if = "Option::is_none") )]
	pub new_crit: Option<MemberCriteria4>,
}

impl MemberCriteriaDefinition2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.qry_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "qry_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "qry_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.new_crit { val.validate()? }
		Ok(())
	}
}


// MemberIdentification3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MemberIdentification3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BICFI", skip_serializing_if = "Option::is_none") )]
	pub bicfi: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrSysMmbId", skip_serializing_if = "Option::is_none") )]
	pub clr_sys_mmb_id: Option<ClearingSystemMemberIdentification2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<GenericFinancialIdentification1>,
}

impl MemberIdentification3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.bicfi {
			let pattern = Regex::new("[A-Z0-9]{4,4}[A-Z]{2,2}[A-Z0-9]{2,2}([A-Z0-9]{3,3}){0,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "bicfi does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.clr_sys_mmb_id { val.validate()? }
		if let Some(ref val) = self.othr { val.validate()? }
		Ok(())
	}
}


// MemberQueryDefinition4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MemberQueryDefinition4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "QryTp", skip_serializing_if = "Option::is_none") )]
	pub qry_tp: Option<QueryType2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MmbCrit", skip_serializing_if = "Option::is_none") )]
	pub mmb_crit: Option<MemberCriteriaDefinition2Choice>,
}

impl MemberQueryDefinition4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.qry_tp { val.validate()? }
		if let Some(ref val) = self.mmb_crit { val.validate()? }
		Ok(())
	}
}


// MemberReport6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MemberReport6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MmbId") )]
	pub mmb_id: MemberIdentification3Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MmbOrErr") )]
	pub mmb_or_err: MemberReportOrError8Choice,
}

impl MemberReport6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.mmb_id.validate()?;
		self.mmb_or_err.validate()?;
		Ok(())
	}
}


// MemberReportOrError7Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MemberReportOrError7Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rpt", skip_serializing_if = "Option::is_none") )]
	pub rpt: Option<Vec<MemberReport6>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OprlErr", skip_serializing_if = "Option::is_none") )]
	pub oprl_err: Option<Vec<ErrorHandling3>>,
}

impl MemberReportOrError7Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.rpt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.oprl_err { for item in vec { item.validate()? } }
		Ok(())
	}
}


// MemberReportOrError8Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MemberReportOrError8Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mmb", skip_serializing_if = "Option::is_none") )]
	pub mmb: Option<Member7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizErr", skip_serializing_if = "Option::is_none") )]
	pub biz_err: Option<ErrorHandling3>,
}

impl MemberReportOrError8Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mmb { val.validate()? }
		if let Some(ref val) = self.biz_err { val.validate()? }
		Ok(())
	}
}


// MemberReturnCriteria1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MemberReturnCriteria1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NmInd", skip_serializing_if = "Option::is_none") )]
	pub nm_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MmbRtrAdrInd", skip_serializing_if = "Option::is_none") )]
	pub mmb_rtr_adr_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctInd", skip_serializing_if = "Option::is_none") )]
	pub acct_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TpInd", skip_serializing_if = "Option::is_none") )]
	pub tp_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsInd", skip_serializing_if = "Option::is_none") )]
	pub sts_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtctRefInd", skip_serializing_if = "Option::is_none") )]
	pub ctct_ref_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ComAdrInd", skip_serializing_if = "Option::is_none") )]
	pub com_adr_ind: Option<bool>,
}

impl MemberReturnCriteria1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// MemberSearchCriteria4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MemberSearchCriteria4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<Vec<MemberIdentification3Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<Vec<SystemMemberType1Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts", skip_serializing_if = "Option::is_none") )]
	pub sts: Option<Vec<SystemMemberStatus1Choice>>,
}

impl MemberSearchCriteria4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.id { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.tp { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.sts { for item in vec { item.validate()? } }
		Ok(())
	}
}


// MemberStatus1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum MemberStatus1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ENBL") )]
	CodeENBL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DSBL") )]
	CodeDSBL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DLTD") )]
	CodeDLTD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "JOIN") )]
	CodeJOIN,
}

impl MemberStatus1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// MessageHeader1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MessageHeader1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm", skip_serializing_if = "Option::is_none") )]
	pub cre_dt_tm: Option<String>,
}

impl MessageHeader1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		Ok(())
	}
}


// MessageHeader10 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MessageHeader10 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm", skip_serializing_if = "Option::is_none") )]
	pub cre_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QryNm", skip_serializing_if = "Option::is_none") )]
	pub qry_nm: Option<String>,
}

impl MessageHeader10 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.qry_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "qry_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "qry_nm exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// MessageHeader11 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MessageHeader11 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm", skip_serializing_if = "Option::is_none") )]
	pub cre_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqTp", skip_serializing_if = "Option::is_none") )]
	pub req_tp: Option<RequestType4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlBizQry", skip_serializing_if = "Option::is_none") )]
	pub orgnl_biz_qry: Option<OriginalBusinessQuery1>,
}

impl MessageHeader11 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.req_tp { val.validate()? }
		if let Some(ref val) = self.orgnl_biz_qry { val.validate()? }
		Ok(())
	}
}


// MessageHeader12 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MessageHeader12 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm", skip_serializing_if = "Option::is_none") )]
	pub cre_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlBizInstr", skip_serializing_if = "Option::is_none") )]
	pub orgnl_biz_instr: Option<OriginalBusinessInstruction1>,
}

impl MessageHeader12 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.orgnl_biz_instr { val.validate()? }
		Ok(())
	}
}


// MessageHeader2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MessageHeader2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm", skip_serializing_if = "Option::is_none") )]
	pub cre_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqTp", skip_serializing_if = "Option::is_none") )]
	pub req_tp: Option<RequestType2Choice>,
}

impl MessageHeader2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.req_tp { val.validate()? }
		Ok(())
	}
}


// MessageHeader3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MessageHeader3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm", skip_serializing_if = "Option::is_none") )]
	pub cre_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqTp", skip_serializing_if = "Option::is_none") )]
	pub req_tp: Option<RequestType2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlBizQry", skip_serializing_if = "Option::is_none") )]
	pub orgnl_biz_qry: Option<OriginalBusinessQuery1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QryNm", skip_serializing_if = "Option::is_none") )]
	pub qry_nm: Option<String>,
}

impl MessageHeader3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.req_tp { val.validate()? }
		if let Some(ref val) = self.orgnl_biz_qry { val.validate()? }
		if let Some(ref val) = self.qry_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "qry_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "qry_nm exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// MessageHeader4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MessageHeader4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm", skip_serializing_if = "Option::is_none") )]
	pub cre_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqTp", skip_serializing_if = "Option::is_none") )]
	pub req_tp: Option<RequestType3Choice>,
}

impl MessageHeader4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.req_tp { val.validate()? }
		Ok(())
	}
}


// MessageHeader6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MessageHeader6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm", skip_serializing_if = "Option::is_none") )]
	pub cre_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlBizQry", skip_serializing_if = "Option::is_none") )]
	pub orgnl_biz_qry: Option<OriginalBusinessQuery1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QryNm", skip_serializing_if = "Option::is_none") )]
	pub qry_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqTp", skip_serializing_if = "Option::is_none") )]
	pub req_tp: Option<RequestType3Choice>,
}

impl MessageHeader6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.orgnl_biz_qry { val.validate()? }
		if let Some(ref val) = self.qry_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "qry_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "qry_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.req_tp { val.validate()? }
		Ok(())
	}
}


// MessageHeader7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MessageHeader7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm", skip_serializing_if = "Option::is_none") )]
	pub cre_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqTp", skip_serializing_if = "Option::is_none") )]
	pub req_tp: Option<RequestType4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlBizQry", skip_serializing_if = "Option::is_none") )]
	pub orgnl_biz_qry: Option<OriginalBusinessQuery1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QryNm", skip_serializing_if = "Option::is_none") )]
	pub qry_nm: Option<String>,
}

impl MessageHeader7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.req_tp { val.validate()? }
		if let Some(ref val) = self.orgnl_biz_qry { val.validate()? }
		if let Some(ref val) = self.qry_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "qry_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "qry_nm exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// MessageHeader8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MessageHeader8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm", skip_serializing_if = "Option::is_none") )]
	pub cre_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgPgntn", skip_serializing_if = "Option::is_none") )]
	pub msg_pgntn: Option<Pagination1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlBizQry", skip_serializing_if = "Option::is_none") )]
	pub orgnl_biz_qry: Option<OriginalBusinessQuery1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqTp", skip_serializing_if = "Option::is_none") )]
	pub req_tp: Option<RequestType4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QryNm", skip_serializing_if = "Option::is_none") )]
	pub qry_nm: Option<String>,
}

impl MessageHeader8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.msg_pgntn { val.validate()? }
		if let Some(ref val) = self.orgnl_biz_qry { val.validate()? }
		if let Some(ref val) = self.req_tp { val.validate()? }
		if let Some(ref val) = self.qry_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "qry_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "qry_nm exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// MessageHeader9 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MessageHeader9 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm", skip_serializing_if = "Option::is_none") )]
	pub cre_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqTp", skip_serializing_if = "Option::is_none") )]
	pub req_tp: Option<RequestType4Choice>,
}

impl MessageHeader9 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.req_tp { val.validate()? }
		Ok(())
	}
}


// MessageIdentification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MessageIdentification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm") )]
	pub cre_dt_tm: String,
}

impl MessageIdentification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		Ok(())
	}
}


// MessageIdentification2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MessageIdentification2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgNmId", skip_serializing_if = "Option::is_none") )]
	pub msg_nm_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId", skip_serializing_if = "Option::is_none") )]
	pub msg_id: Option<String>,
}

impl MessageIdentification2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.msg_nm_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "msg_nm_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "msg_nm_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.msg_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// MessageIdentification8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MessageIdentification8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId", skip_serializing_if = "Option::is_none") )]
	pub msg_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm", skip_serializing_if = "Option::is_none") )]
	pub cre_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrstAgt", skip_serializing_if = "Option::is_none") )]
	pub frst_agt: Option<BranchAndFinancialInstitutionIdentification8>,
}

impl MessageIdentification8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.msg_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.frst_agt { val.validate()? }
		Ok(())
	}
}


// MessageReference ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MessageReference {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ref") )]
	pub ref_attr: String,
}

impl MessageReference {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.ref_attr.chars().count() < 1 {
			return Err(ValidationError::new(1001, "ref_attr is shorter than the minimum length of 1".to_string()));
		}
		if self.ref_attr.chars().count() > 35 {
			return Err(ValidationError::new(1002, "ref_attr exceeds the maximum length of 35".to_string()));
		}
		Ok(())
	}
}


// MessageReference1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MessageReference1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ref") )]
	pub ref_attr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgNm", skip_serializing_if = "Option::is_none") )]
	pub msg_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RefIssr", skip_serializing_if = "Option::is_none") )]
	pub ref_issr: Option<PartyIdentification136>,
}

impl MessageReference1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.ref_attr.chars().count() < 1 {
			return Err(ValidationError::new(1001, "ref_attr is shorter than the minimum length of 1".to_string()));
		}
		if self.ref_attr.chars().count() > 35 {
			return Err(ValidationError::new(1002, "ref_attr exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.msg_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "msg_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "msg_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.ref_issr { val.validate()? }
		Ok(())
	}
}


// MessageReportHeader4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MessageReportHeader4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgRptIdr", skip_serializing_if = "Option::is_none") )]
	pub msg_rpt_idr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgSts", skip_serializing_if = "Option::is_none") )]
	pub msg_sts: Option<StatusAdviceReport3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RcrdSts", skip_serializing_if = "Option::is_none") )]
	pub rcrd_sts: Option<Vec<StatusReportRecord3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl MessageReportHeader4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.msg_rpt_idr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "msg_rpt_idr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "msg_rpt_idr exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.msg_sts { val.validate()? }
		if let Some(ref vec) = self.rcrd_sts { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// MetalCommodityNonPrecious1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MetalCommodityNonPrecious1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType7Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType15Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlSubPdct") )]
	pub addtl_sub_pdct: AssetClassDetailedSubProductType10Code,
}

impl MetalCommodityNonPrecious1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		self.addtl_sub_pdct.validate()?;
		Ok(())
	}
}


// MetalCommodityNonPrecious2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MetalCommodityNonPrecious2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType7Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType15Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlSubPdct", skip_serializing_if = "Option::is_none") )]
	pub addtl_sub_pdct: Option<AssetClassDetailedSubProductType10Code>,
}

impl MetalCommodityNonPrecious2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		if let Some(ref val) = self.addtl_sub_pdct { val.validate()? }
		Ok(())
	}
}


// MetalCommodityPrecious1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MetalCommodityPrecious1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType7Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType16Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlSubPdct") )]
	pub addtl_sub_pdct: AssetClassDetailedSubProductType11Code,
}

impl MetalCommodityPrecious1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		self.addtl_sub_pdct.validate()?;
		Ok(())
	}
}


// MetalCommodityPrecious2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MetalCommodityPrecious2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType7Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType16Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlSubPdct", skip_serializing_if = "Option::is_none") )]
	pub addtl_sub_pdct: Option<AssetClassDetailedSubProductType11Code>,
}

impl MetalCommodityPrecious2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		if let Some(ref val) = self.addtl_sub_pdct { val.validate()? }
		Ok(())
	}
}


// MiFIDClassification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MiFIDClassification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Clssfctn") )]
	pub clssfctn: OrderOriginatorEligibility1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nrrtv", skip_serializing_if = "Option::is_none") )]
	pub nrrtv: Option<String>,
}

impl MiFIDClassification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.clssfctn.validate()?;
		if let Some(ref val) = self.nrrtv {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nrrtv is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "nrrtv exceeds the maximum length of 350".to_string()));
			}
		}
		Ok(())
	}
}


// MinimumExecutable1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MinimumExecutable1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sz", skip_serializing_if = "Option::is_none") )]
	pub sz: Option<FinancialInstrumentQuantity25Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrstExctnOnly", skip_serializing_if = "Option::is_none") )]
	pub frst_exctn_only: Option<bool>,
}

impl MinimumExecutable1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.sz { val.validate()? }
		Ok(())
	}
}


// MissingCover6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MissingCover6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MssngCoverInd") )]
	pub mssng_cover_ind: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CoverCrrctn", skip_serializing_if = "Option::is_none") )]
	pub cover_crrctn: Option<SettlementInstruction16>,
}

impl MissingCover6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cover_crrctn { val.validate()? }
		Ok(())
	}
}


// MissingData1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MissingData1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl MissingData1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// MissingMarginData2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MissingMarginData2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtyId") )]
	pub ctr_pty_id: CounterpartyData92,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfOutsdngDerivs") )]
	pub nb_of_outsdng_derivs: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfOutsdngDerivsWthNoMrgnInf") )]
	pub nb_of_outsdng_derivs_wth_no_mrgn_inf: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfOutsdngDerivsWthOutdtdMrgnInf") )]
	pub nb_of_outsdng_derivs_wth_outdtd_mrgn_inf: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxDtls", skip_serializing_if = "Option::is_none") )]
	pub tx_dtls: Option<Vec<MissingMarginTransactionData2>>,
}

impl MissingMarginData2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.ctr_pty_id.validate()?;
		if let Some(ref vec) = self.tx_dtls { for item in vec { item.validate()? } }
		Ok(())
	}
}


// MissingMarginTransactionData2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MissingMarginTransactionData2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxId") )]
	pub tx_id: TradeTransactionIdentification24,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollTmStmp", skip_serializing_if = "Option::is_none") )]
	pub coll_tm_stmp: Option<String>,
}

impl MissingMarginTransactionData2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tx_id.validate()?;
		Ok(())
	}
}


// MissingOrIncorrectData1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MissingOrIncorrectData1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AMLReq", skip_serializing_if = "Option::is_none") )]
	pub aml_req: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MssngInf", skip_serializing_if = "Option::is_none") )]
	pub mssng_inf: Option<Vec<UnableToApplyMissing2>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IncrrctInf", skip_serializing_if = "Option::is_none") )]
	pub incrrct_inf: Option<Vec<UnableToApplyIncorrect2>>,
}

impl MissingOrIncorrectData1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.mssng_inf { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.incrrct_inf { for item in vec { item.validate()? } }
		Ok(())
	}
}


// MissingValuationsData2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MissingValuationsData2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtyId") )]
	pub ctr_pty_id: CounterpartyData92,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfOutsdngDerivs") )]
	pub nb_of_outsdng_derivs: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfOutsdngDerivsWthNoValtn") )]
	pub nb_of_outsdng_derivs_wth_no_valtn: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfOutsdngDerivsWthOutdtdValtn") )]
	pub nb_of_outsdng_derivs_wth_outdtd_valtn: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxDtls", skip_serializing_if = "Option::is_none") )]
	pub tx_dtls: Option<Vec<MissingValuationsTransactionData2>>,
}

impl MissingValuationsData2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.ctr_pty_id.validate()?;
		if let Some(ref vec) = self.tx_dtls { for item in vec { item.validate()? } }
		Ok(())
	}
}


// MissingValuationsTransactionData2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MissingValuationsTransactionData2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxId") )]
	pub tx_id: TradeTransactionIdentification24,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValtnAmt", skip_serializing_if = "Option::is_none") )]
	pub valtn_amt: Option<AmountAndDirection106>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValtnTmStmp", skip_serializing_if = "Option::is_none") )]
	pub valtn_tm_stmp: Option<DateAndDateTime2Choice>,
}

impl MissingValuationsTransactionData2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tx_id.validate()?;
		if let Some(ref val) = self.valtn_amt { val.validate()? }
		if let Some(ref val) = self.valtn_tm_stmp { val.validate()? }
		Ok(())
	}
}


// ModelType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ModelType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<ModelType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification36>,
}

impl ModelType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// ModelType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ModelType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "EXPS") )]
	CodeEXPS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ORIA") )]
	CodeORIA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SPAN") )]
	CodeSPAN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VARI") )]
	CodeVARI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SAMO") )]
	CodeSAMO,
}

impl ModelType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Modification1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum Modification1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "NOCH") )]
	CodeNOCH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MODI") )]
	CodeMODI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DELE") )]
	CodeDELE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ADDD") )]
	CodeADDD,
}

impl Modification1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ModificationLevel1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ModificationLevel1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "PSTN") )]
	CodePSTN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TCTN") )]
	CodeTCTN,
}

impl ModificationLevel1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ModificationProcessingStatus1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ModificationProcessingStatus1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "PACK") )]
	CodePACK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REJT") )]
	CodeREJT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MODC") )]
	CodeMODC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DEND") )]
	CodeDEND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MODP") )]
	CodeMODP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REPR") )]
	CodeREPR,
}

impl ModificationProcessingStatus1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ModificationProcessingStatus9Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ModificationProcessingStatus9Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<ModificationProcessingStatus1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl ModificationProcessingStatus9Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// ModificationScope21 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ModificationScope21 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModScpIndctn") )]
	pub mod_scp_indctn: DataModification1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IsseAllcn") )]
	pub isse_allcn: NewIssueAllocation2,
}

impl ModificationScope21 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.mod_scp_indctn.validate()?;
		self.isse_allcn.validate()?;
		Ok(())
	}
}


// ModificationScope27 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ModificationScope27 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModScpIndctn") )]
	pub mod_scp_indctn: DataModification2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstrPrflVldtn") )]
	pub invstr_prfl_vldtn: PartyProfileInformation5,
}

impl ModificationScope27 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.mod_scp_indctn.validate()?;
		self.invstr_prfl_vldtn.validate()?;
		Ok(())
	}
}


// ModificationScope34 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ModificationScope34 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModScpIndctn") )]
	pub mod_scp_indctn: DataModification1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstlAdr") )]
	pub pstl_adr: PostalAddress21,
}

impl ModificationScope34 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.mod_scp_indctn.validate()?;
		self.pstl_adr.validate()?;
		Ok(())
	}
}


// ModificationScope39 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ModificationScope39 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModScpIndctn") )]
	pub mod_scp_indctn: DataModification2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctznsh") )]
	pub ctznsh: CitizenshipInformation2,
}

impl ModificationScope39 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.mod_scp_indctn.validate()?;
		self.ctznsh.validate()?;
		Ok(())
	}
}


// ModificationScope40 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ModificationScope40 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModScpIndctn") )]
	pub mod_scp_indctn: DataModification1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Intrmy") )]
	pub intrmy: Intermediary46,
}

impl ModificationScope40 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.mod_scp_indctn.validate()?;
		self.intrmy.validate()?;
		Ok(())
	}
}


// ModificationScope41 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ModificationScope41 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModScpIndctn") )]
	pub mod_scp_indctn: DataModification1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstmtPlan") )]
	pub invstmt_plan: InvestmentPlan16,
}

impl ModificationScope41 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.mod_scp_indctn.validate()?;
		self.invstmt_plan.validate()?;
		Ok(())
	}
}


// ModificationScope42 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ModificationScope42 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModScpIndctn") )]
	pub mod_scp_indctn: DataModification2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmDtls") )]
	pub fin_instrm_dtls: FinancialInstrument87,
}

impl ModificationScope42 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.mod_scp_indctn.validate()?;
		self.fin_instrm_dtls.validate()?;
		Ok(())
	}
}


// ModificationScope43 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ModificationScope43 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModScpIndctn") )]
	pub mod_scp_indctn: DataModification1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Plcmnt") )]
	pub plcmnt: ReferredAgent3,
}

impl ModificationScope43 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.mod_scp_indctn.validate()?;
		self.plcmnt.validate()?;
		Ok(())
	}
}


// ModificationScope44 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ModificationScope44 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModScpIndctn") )]
	pub mod_scp_indctn: DataModification1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SvcLvlAgrmt") )]
	pub svc_lvl_agrmt: DocumentToSend4,
}

impl ModificationScope44 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.mod_scp_indctn.validate()?;
		self.svc_lvl_agrmt.validate()?;
		Ok(())
	}
}


// ModificationScope45 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ModificationScope45 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModScpIndctn") )]
	pub mod_scp_indctn: DataModification1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf") )]
	pub addtl_inf: Vec<AdditiononalInformation13>,
}

impl ModificationScope45 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.mod_scp_indctn.validate()?;
		for item in &self.addtl_inf { item.validate()? }
		Ok(())
	}
}


// ModificationScope46 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ModificationScope46 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModScpIndctn") )]
	pub mod_scp_indctn: DataModification1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstrPrfl") )]
	pub invstr_prfl: InvestorProfile2,
}

impl ModificationScope46 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.mod_scp_indctn.validate()?;
		self.invstr_prfl.validate()?;
		Ok(())
	}
}


// ModificationStatusReason1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ModificationStatusReason1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl ModificationStatusReason1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// ModificationStatusReason3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ModificationStatusReason3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Orgtr", skip_serializing_if = "Option::is_none") )]
	pub orgtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<ModificationStatusReason1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<Vec<String>>,
}

impl ModificationStatusReason3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgtr { val.validate()? }
		if let Some(ref val) = self.rsn { val.validate()? }
		if let Some(ref vec) = self.addtl_inf {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 105 {
					return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 105".to_string()));
				}
			}
		}
		Ok(())
	}
}


// MoneyLaunderingCheck1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MoneyLaunderingCheck1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<MoneyLaunderingCheck1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl MoneyLaunderingCheck1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// MoneyLaunderingCheck1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum MoneyLaunderingCheck1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "PASS") )]
	CodePASS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NOTC") )]
	CodeNOTC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EXEM") )]
	CodeEXEM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CLMO") )]
	CodeCLMO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AUTH") )]
	CodeAUTH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "POEP") )]
	CodePOEP,
}

impl MoneyLaunderingCheck1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// MoneyMarketReportHeader1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MoneyMarketReportHeader1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgAgt") )]
	pub rptg_agt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RefPrd") )]
	pub ref_prd: DateTimePeriod1,
}

impl MoneyMarketReportHeader1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
		if !pattern.is_match(&self.rptg_agt) {
			return Err(ValidationError::new(1005, "rptg_agt does not match the required pattern".to_string()));
		}
		self.ref_prd.validate()?;
		Ok(())
	}
}


// MoneyMarketStatusReportHeader1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MoneyMarketStatusReportHeader1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgAgt") )]
	pub rptg_agt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgPrd") )]
	pub rptg_prd: DateTimePeriod1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptSts") )]
	pub rpt_sts: StatisticalReportingStatus1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldtnRule", skip_serializing_if = "Option::is_none") )]
	pub vldtn_rule: Option<Vec<GenericValidationRuleIdentification1>>,
}

impl MoneyMarketStatusReportHeader1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
		if !pattern.is_match(&self.rptg_agt) {
			return Err(ValidationError::new(1005, "rptg_agt does not match the required pattern".to_string()));
		}
		self.rptg_prd.validate()?;
		self.rpt_sts.validate()?;
		if let Some(ref vec) = self.vldtn_rule { for item in vec { item.validate()? } }
		Ok(())
	}
}


// MoneyMarketTransactionStatus2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MoneyMarketTransactionStatus2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnqTxIdr", skip_serializing_if = "Option::is_none") )]
	pub unq_tx_idr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtryTxId") )]
	pub prtry_tx_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BrnchId", skip_serializing_if = "Option::is_none") )]
	pub brnch_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts") )]
	pub sts: StatisticalReportingStatus2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldtnRule", skip_serializing_if = "Option::is_none") )]
	pub vldtn_rule: Option<Vec<GenericValidationRuleIdentification1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl MoneyMarketTransactionStatus2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.unq_tx_idr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "unq_tx_idr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 105 {
				return Err(ValidationError::new(1002, "unq_tx_idr exceeds the maximum length of 105".to_string()));
			}
		}
		if self.prtry_tx_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "prtry_tx_id is shorter than the minimum length of 1".to_string()));
		}
		if self.prtry_tx_id.chars().count() > 105 {
			return Err(ValidationError::new(1002, "prtry_tx_id exceeds the maximum length of 105".to_string()));
		}
		if let Some(ref val) = self.brnch_id {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "brnch_id does not match the required pattern".to_string()));
			}
		}
		self.sts.validate()?;
		if let Some(ref vec) = self.vldtn_rule { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// MoneyMarketTransactionType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum MoneyMarketTransactionType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "BORR") )]
	CodeBORR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LEND") )]
	CodeLEND,
}

impl MoneyMarketTransactionType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// MonthlyResult1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MonthlyResult1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfObsrvtns") )]
	pub nb_of_obsrvtns: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfXcptns") )]
	pub nb_of_xcptns: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cvrg") )]
	pub cvrg: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LrgstXcptn") )]
	pub lrgst_xcptn: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AvrgXcptn") )]
	pub avrg_xcptn: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LrgstXcptnId", skip_serializing_if = "Option::is_none") )]
	pub lrgst_xcptn_id: Option<GenericIdentification165>,
}

impl MonthlyResult1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.nb_of_obsrvtns < 1.000000 {
			return Err(ValidationError::new(1003, "nb_of_obsrvtns is less than the minimum value of 1.000000".to_string()));
		}
		if self.nb_of_xcptns < 0.000000 {
			return Err(ValidationError::new(1003, "nb_of_xcptns is less than the minimum value of 0.000000".to_string()));
		}
		self.lrgst_xcptn.validate()?;
		self.avrg_xcptn.validate()?;
		if let Some(ref val) = self.lrgst_xcptn_id { val.validate()? }
		Ok(())
	}
}


// MovementRecord2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MovementRecord2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SeqNb", skip_serializing_if = "Option::is_none") )]
	pub seq_nb: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: AmountAndDirection5,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmAgt", skip_serializing_if = "Option::is_none") )]
	pub sttlm_agt: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub sttlm_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ptcpt", skip_serializing_if = "Option::is_none") )]
	pub ptcpt: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtcptAcct", skip_serializing_if = "Option::is_none") )]
	pub ptcpt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ref", skip_serializing_if = "Option::is_none") )]
	pub ref_attr: Option<String>,
}

impl MovementRecord2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		self.amt.validate()?;
		if let Some(ref val) = self.sttlm_agt { val.validate()? }
		if let Some(ref val) = self.sttlm_agt_acct { val.validate()? }
		if let Some(ref val) = self.ptcpt { val.validate()? }
		if let Some(ref val) = self.ptcpt_acct { val.validate()? }
		if let Some(ref val) = self.ref_attr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ref_attr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "ref_attr exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// MovementReport1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MovementReport1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "QryRef", skip_serializing_if = "Option::is_none") )]
	pub qry_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptId", skip_serializing_if = "Option::is_none") )]
	pub rpt_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QryTp") )]
	pub qry_tp: MovementResponseType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ActvtyInd") )]
	pub actvty_ind: bool,
}

impl MovementReport1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.qry_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "qry_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "qry_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.rpt_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rpt_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "rpt_id exceeds the maximum length of 35".to_string()));
			}
		}
		self.qry_tp.validate()?;
		Ok(())
	}
}


// MovementResponseType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum MovementResponseType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "FULL") )]
	CodeFULL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "STTS") )]
	CodeSTTS,
}

impl MovementResponseType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// MultilateralSettlementRequest3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct MultilateralSettlementRequest3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrId") )]
	pub instr_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrPrty", skip_serializing_if = "Option::is_none") )]
	pub instr_prty: Option<Priority3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmTmReq", skip_serializing_if = "Option::is_none") )]
	pub sttlm_tm_req: Option<SettlementTimeRequest2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmPrty", skip_serializing_if = "Option::is_none") )]
	pub sttlm_prty: Option<Priority3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmCycl", skip_serializing_if = "Option::is_none") )]
	pub sttlm_cycl: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfMvmntRcrds", skip_serializing_if = "Option::is_none") )]
	pub nb_of_mvmnt_rcrds: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MvmntRcrd") )]
	pub mvmnt_rcrd: Vec<MovementRecord2>,
}

impl MultilateralSettlementRequest3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.instr_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "instr_id is shorter than the minimum length of 1".to_string()));
		}
		if self.instr_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "instr_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.instr_prty { val.validate()? }
		if let Some(ref val) = self.sttlm_tm_req { val.validate()? }
		if let Some(ref val) = self.sttlm_prty { val.validate()? }
		if let Some(ref val) = self.sttlm_cycl {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "sttlm_cycl is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "sttlm_cycl exceeds the maximum length of 35".to_string()));
			}
		}
		for item in &self.mvmnt_rcrd { item.validate()? }
		Ok(())
	}
}


// NameAndAddress15 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NameAndAddress15 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm") )]
	pub nm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstlAdr", skip_serializing_if = "Option::is_none") )]
	pub pstl_adr: Option<PostalAddress21>,
}

impl NameAndAddress15 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
		}
		if self.nm.chars().count() > 350 {
			return Err(ValidationError::new(1002, "nm exceeds the maximum length of 350".to_string()));
		}
		if let Some(ref val) = self.pstl_adr { val.validate()? }
		Ok(())
	}
}


// NameAndAddress16 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NameAndAddress16 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm") )]
	pub nm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Adr") )]
	pub adr: PostalAddress24,
}

impl NameAndAddress16 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
		}
		if self.nm.chars().count() > 140 {
			return Err(ValidationError::new(1002, "nm exceeds the maximum length of 140".to_string()));
		}
		self.adr.validate()?;
		Ok(())
	}
}


// NameAndAddress18 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NameAndAddress18 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm") )]
	pub nm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Adr") )]
	pub adr: PostalAddress27,
}

impl NameAndAddress18 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
		}
		if self.nm.chars().count() > 140 {
			return Err(ValidationError::new(1002, "nm exceeds the maximum length of 140".to_string()));
		}
		self.adr.validate()?;
		Ok(())
	}
}


// NameAndAddress4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NameAndAddress4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Adr") )]
	pub adr: PostalAddress1,
}

impl NameAndAddress4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 350".to_string()));
			}
		}
		self.adr.validate()?;
		Ok(())
	}
}


// NameAndAddress5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NameAndAddress5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm") )]
	pub nm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Adr", skip_serializing_if = "Option::is_none") )]
	pub adr: Option<PostalAddress1>,
}

impl NameAndAddress5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
		}
		if self.nm.chars().count() > 350 {
			return Err(ValidationError::new(1002, "nm exceeds the maximum length of 350".to_string()));
		}
		if let Some(ref val) = self.adr { val.validate()? }
		Ok(())
	}
}


// NameAndAddress8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NameAndAddress8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm") )]
	pub nm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Adr", skip_serializing_if = "Option::is_none") )]
	pub adr: Option<PostalAddress1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AltrntvIdr", skip_serializing_if = "Option::is_none") )]
	pub altrntv_idr: Option<Vec<String>>,
}

impl NameAndAddress8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
		}
		if self.nm.chars().count() > 350 {
			return Err(ValidationError::new(1002, "nm exceeds the maximum length of 350".to_string()));
		}
		if let Some(ref val) = self.adr { val.validate()? }
		if let Some(ref vec) = self.altrntv_idr {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "altrntv_idr is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 35 {
					return Err(ValidationError::new(1002, "altrntv_idr exceeds the maximum length of 35".to_string()));
				}
			}
		}
		Ok(())
	}
}


// NameAndLocation1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NameAndLocation1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm") )]
	pub nm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Lctn") )]
	pub lctn: String,
}

impl NameAndLocation1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
		}
		if self.nm.chars().count() > 70 {
			return Err(ValidationError::new(1002, "nm exceeds the maximum length of 70".to_string()));
		}
		let pattern = Regex::new("[A-Z]{2,2}").unwrap();
		if !pattern.is_match(&self.lctn) {
			return Err(ValidationError::new(1005, "lctn does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// NameModification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NameModification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModCd", skip_serializing_if = "Option::is_none") )]
	pub mod_cd: Option<Modification1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm") )]
	pub nm: String,
}

impl NameModification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mod_cd { val.validate()? }
		if self.nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
		}
		if self.nm.chars().count() > 70 {
			return Err(ValidationError::new(1002, "nm exceeds the maximum length of 70".to_string()));
		}
		Ok(())
	}
}


// NamePrefix1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NamePrefix1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<NamePrefix1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl NamePrefix1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// NamePrefix1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum NamePrefix1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "DOCT") )]
	CodeDOCT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MIST") )]
	CodeMIST,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MISS") )]
	CodeMISS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MADM") )]
	CodeMADM,
}

impl NamePrefix1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// NamePrefix2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum NamePrefix2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "DOCT") )]
	CodeDOCT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MADM") )]
	CodeMADM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MISS") )]
	CodeMISS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MIST") )]
	CodeMIST,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MIKS") )]
	CodeMIKS,
}

impl NamePrefix2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// NamedPosition3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NamedPosition3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RefDt") )]
	pub ref_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GnlInf", skip_serializing_if = "Option::is_none") )]
	pub gnl_inf: Option<Vec<PositionSet16>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ln", skip_serializing_if = "Option::is_none") )]
	pub ln: Option<Vec<PositionSet17>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Coll", skip_serializing_if = "Option::is_none") )]
	pub coll: Option<Vec<PositionSet18>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mrgn", skip_serializing_if = "Option::is_none") )]
	pub mrgn: Option<Vec<PositionSet20>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Reuse", skip_serializing_if = "Option::is_none") )]
	pub reuse: Option<Vec<PositionSet19>>,
}

impl NamedPosition3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.gnl_inf { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.ln { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.coll { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.mrgn { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.reuse { for item in vec { item.validate()? } }
		Ok(())
	}
}


// NaturalPersonIdentification2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NaturalPersonIdentification2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: GenericIdentification175,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dmcl", skip_serializing_if = "Option::is_none") )]
	pub dmcl: Option<String>,
}

impl NaturalPersonIdentification2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.id.validate()?;
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 105 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 105".to_string()));
			}
		}
		if let Some(ref val) = self.dmcl {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "dmcl is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 500 {
				return Err(ValidationError::new(1002, "dmcl exceeds the maximum length of 500".to_string()));
			}
		}
		Ok(())
	}
}


// NaturalPersonIdentification3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NaturalPersonIdentification3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: NaturalPersonIdentification2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctry", skip_serializing_if = "Option::is_none") )]
	pub ctry: Option<String>,
}

impl NaturalPersonIdentification3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.id.validate()?;
		if let Some(ref val) = self.ctry {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// NetCashForecast3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NetCashForecast3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NetAmt", skip_serializing_if = "Option::is_none") )]
	pub net_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NetUnitsNb", skip_serializing_if = "Option::is_none") )]
	pub net_units_nb: Option<FinancialInstrumentQuantity1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FlowDrctn") )]
	pub flow_drctn: FlowDirectionType1Code,
}

impl NetCashForecast3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.net_amt { val.validate()? }
		if let Some(ref val) = self.net_units_nb { val.validate()? }
		self.flow_drctn.validate()?;
		Ok(())
	}
}


// NetCashForecast4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NetCashForecast4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshSttlmDt") )]
	pub csh_sttlm_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NetAmt", skip_serializing_if = "Option::is_none") )]
	pub net_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NetUnitsNb", skip_serializing_if = "Option::is_none") )]
	pub net_units_nb: Option<FinancialInstrumentQuantity1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FlowDrctn") )]
	pub flow_drctn: FlowDirectionType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlBal", skip_serializing_if = "Option::is_none") )]
	pub addtl_bal: Option<FundBalance1>,
}

impl NetCashForecast4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.net_amt { val.validate()? }
		if let Some(ref val) = self.net_units_nb { val.validate()? }
		self.flow_drctn.validate()?;
		if let Some(ref val) = self.addtl_bal { val.validate()? }
		Ok(())
	}
}


// NetCashForecast5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NetCashForecast5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshSttlmDt", skip_serializing_if = "Option::is_none") )]
	pub csh_sttlm_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NetAmt", skip_serializing_if = "Option::is_none") )]
	pub net_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NetUnitsNb", skip_serializing_if = "Option::is_none") )]
	pub net_units_nb: Option<FinancialInstrumentQuantity1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FlowDrctn") )]
	pub flow_drctn: FlowDirectionType1Code,
}

impl NetCashForecast5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.net_amt { val.validate()? }
		if let Some(ref val) = self.net_units_nb { val.validate()? }
		self.flow_drctn.validate()?;
		Ok(())
	}
}


// NetObligation2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NetObligation2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OblgtnId") )]
	pub oblgtn_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtcptNetgId") )]
	pub ptcpt_netg_id: NettingIdentification2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OblgtnDrctn") )]
	pub oblgtn_drctn: PaymentReceipt1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtyNetgId") )]
	pub ctr_pty_netg_id: NettingIdentification2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NetSvcCtrPtyId", skip_serializing_if = "Option::is_none") )]
	pub net_svc_ctr_pty_id: Option<PartyIdentification242Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtySttlmInstrs", skip_serializing_if = "Option::is_none") )]
	pub ctr_pty_sttlm_instrs: Option<SettlementParties120>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxsNb", skip_serializing_if = "Option::is_none") )]
	pub txs_nb: Option<String>,
}

impl NetObligation2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.oblgtn_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "oblgtn_id is shorter than the minimum length of 1".to_string()));
		}
		if self.oblgtn_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "oblgtn_id exceeds the maximum length of 35".to_string()));
		}
		self.amt.validate()?;
		self.ptcpt_netg_id.validate()?;
		self.oblgtn_drctn.validate()?;
		self.ctr_pty_netg_id.validate()?;
		if let Some(ref val) = self.net_svc_ctr_pty_id { val.validate()? }
		if let Some(ref val) = self.ctr_pty_sttlm_instrs { val.validate()? }
		if let Some(ref val) = self.txs_nb {
			let pattern = Regex::new("[0-9]{1,10}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "txs_nb does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// NetReportData2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NetReportData2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm") )]
	pub cre_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NetgCutOffTm") )]
	pub netg_cut_off_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptDt") )]
	pub rpt_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValDt") )]
	pub val_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptTp", skip_serializing_if = "Option::is_none") )]
	pub rpt_tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NetRptSvcr", skip_serializing_if = "Option::is_none") )]
	pub net_rpt_svcr: Option<PartyIdentification242Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NetSvcTp", skip_serializing_if = "Option::is_none") )]
	pub net_svc_tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgPgntn", skip_serializing_if = "Option::is_none") )]
	pub msg_pgntn: Option<Pagination1>,
}

impl NetReportData2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.rpt_tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rpt_tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "rpt_tp exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.net_rpt_svcr { val.validate()? }
		if let Some(ref val) = self.net_svc_tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "net_svc_tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "net_svc_tp exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.msg_pgntn { val.validate()? }
		Ok(())
	}
}


// NettingCutOff2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NettingCutOff2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NetgId") )]
	pub netg_id: NettingIdentification2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NewCutOff") )]
	pub new_cut_off: Vec<CutOff1>,
}

impl NettingCutOff2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.netg_id.validate()?;
		for item in &self.new_cut_off { item.validate()? }
		Ok(())
	}
}


// NettingCutOffReportData2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NettingCutOffReportData2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm") )]
	pub cre_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptTp") )]
	pub rpt_tp: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ActvtnDt") )]
	pub actvtn_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NetSvcPtcptId", skip_serializing_if = "Option::is_none") )]
	pub net_svc_ptcpt_id: Option<PartyIdentification242Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptSvcr", skip_serializing_if = "Option::is_none") )]
	pub rpt_svcr: Option<PartyIdentification242Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NetSvcTp", skip_serializing_if = "Option::is_none") )]
	pub net_svc_tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgPgntn", skip_serializing_if = "Option::is_none") )]
	pub msg_pgntn: Option<Pagination1>,
}

impl NettingCutOffReportData2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		if self.rpt_tp.chars().count() < 1 {
			return Err(ValidationError::new(1001, "rpt_tp is shorter than the minimum length of 1".to_string()));
		}
		if self.rpt_tp.chars().count() > 4 {
			return Err(ValidationError::new(1002, "rpt_tp exceeds the maximum length of 4".to_string()));
		}
		if let Some(ref val) = self.net_svc_ptcpt_id { val.validate()? }
		if let Some(ref val) = self.rpt_svcr { val.validate()? }
		if let Some(ref val) = self.net_svc_tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "net_svc_tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "net_svc_tp exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.msg_pgntn { val.validate()? }
		Ok(())
	}
}


// NettingIdentification2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NettingIdentification2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradPty", skip_serializing_if = "Option::is_none") )]
	pub trad_pty: Option<PartyIdentification242Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NetgGrpId", skip_serializing_if = "Option::is_none") )]
	pub netg_grp_id: Option<String>,
}

impl NettingIdentification2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.trad_pty { val.validate()? }
		if let Some(ref val) = self.netg_grp_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "netg_grp_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "netg_grp_id exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// NewAccount4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NewAccount4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Acct") )]
	pub acct: CashAccount43,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctPty") )]
	pub acct_pty: Vec<IndividualPerson44>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Org", skip_serializing_if = "Option::is_none") )]
	pub org: Option<Organisation43>,
}

impl NewAccount4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.acct.validate()?;
		for item in &self.acct_pty { item.validate()? }
		if let Some(ref val) = self.org { val.validate()? }
		Ok(())
	}
}


// NewIssueAllocation2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NewIssueAllocation2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rstrctd") )]
	pub rstrctd: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XmptPrsnRsn", skip_serializing_if = "Option::is_none") )]
	pub xmpt_prsn_rsn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DeMnms", skip_serializing_if = "Option::is_none") )]
	pub de_mnms: Option<DeMinimus1Choice>,
}

impl NewIssueAllocation2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.xmpt_prsn_rsn {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "xmpt_prsn_rsn is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "xmpt_prsn_rsn exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.de_mnms { val.validate()? }
		Ok(())
	}
}


// NewOrderReport2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NewOrderReport2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptId") )]
	pub rpt_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ordr") )]
	pub ordr: Vec<OrderData3>,
}

impl NewOrderReport2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.rpt_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "rpt_id is shorter than the minimum length of 1".to_string()));
		}
		if self.rpt_id.chars().count() > 140 {
			return Err(ValidationError::new(1002, "rpt_id exceeds the maximum length of 140".to_string()));
		}
		for item in &self.ordr { item.validate()? }
		Ok(())
	}
}


// NoCriteria1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum NoCriteria1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "NOCR") )]
	CodeNOCR,
}

impl NoCriteria1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// NoReasonCode ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum NoReasonCode {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "NORE") )]
	CodeNORE,
}

impl NoReasonCode {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// NonClearingReason2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NonClearingReason2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrXmptnXcptn") )]
	pub clr_xmptn_xcptn: Vec<ClearingExemptionException1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NonClrRsnInf", skip_serializing_if = "Option::is_none") )]
	pub non_clr_rsn_inf: Option<String>,
}

impl NonClearingReason2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		for item in &self.clr_xmptn_xcptn { item.validate()? }
		if let Some(ref val) = self.non_clr_rsn_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "non_clr_rsn_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "non_clr_rsn_inf exceeds the maximum length of 350".to_string()));
			}
		}
		Ok(())
	}
}


// NonEquityAssetClass1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum NonEquityAssetClass1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "SDRV") )]
	CodeSDRV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IRDV") )]
	CodeIRDV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FEXD") )]
	CodeFEXD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EQDV") )]
	CodeEQDV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EADV") )]
	CodeEADV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EMAL") )]
	CodeEMAL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CRDV") )]
	CodeCRDV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CFDS") )]
	CodeCFDS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "COMD") )]
	CodeCOMD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "C10D") )]
	CodeC10D,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BOND") )]
	CodeBOND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ETCS") )]
	CodeETCS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ETNS") )]
	CodeETNS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SFPS") )]
	CodeSFPS,
}

impl NonEquityAssetClass1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// NonEquityInstrumentReportingClassification1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum NonEquityInstrumentReportingClassification1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "SFPS") )]
	CodeSFPS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SDRV") )]
	CodeSDRV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DERV") )]
	CodeDERV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EMAL") )]
	CodeEMAL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BOND") )]
	CodeBOND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ETCS") )]
	CodeETCS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ETNS") )]
	CodeETNS,
}

impl NonEquityInstrumentReportingClassification1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// NonEquitySubClass1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NonEquitySubClass1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Desc", skip_serializing_if = "Option::is_none") )]
	pub desc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SgmttnCrit") )]
	pub sgmttn_crit: Vec<NonEquitySubClassSegmentationCriterion1>,
}

impl NonEquitySubClass1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.desc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "desc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 1000 {
				return Err(ValidationError::new(1002, "desc exceeds the maximum length of 1000".to_string()));
			}
		}
		for item in &self.sgmttn_crit { item.validate()? }
		Ok(())
	}
}


// NonEquitySubClassSegmentationCriteria1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum NonEquitySubClassSegmentationCriteria1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ASCL") )]
	CodeASCL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BSPD") )]
	CodeBSPD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CNC1") )]
	CodeCNC1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CNC2") )]
	CodeCNC2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NCCO") )]
	CodeNCCO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CTYP") )]
	CodeCTYP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NCCR") )]
	CodeNCCR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DCSL") )]
	CodeDCSL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DTYP") )]
	CodeDTYP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EQUT") )]
	CodeEQUT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FNC1") )]
	CodeFNC1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FNC2") )]
	CodeFNC2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FSPD") )]
	CodeFSPD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IIND") )]
	CodeIIND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IRTC") )]
	CodeIRTC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INC1") )]
	CodeINC1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INC2") )]
	CodeINC2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISIN") )]
	CodeISIN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TTMO") )]
	CodeTTMO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRMT") )]
	CodePRMT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SSRF") )]
	CodeSSRF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISPT") )]
	CodeISPT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SRTC") )]
	CodeSRTC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SACL") )]
	CodeSACL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SBPD") )]
	CodeSBPD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TTMS") )]
	CodeTTMS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NCSW") )]
	CodeNCSW,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TTMB") )]
	CodeTTMB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IOUB") )]
	CodeIOUB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TOUB") )]
	CodeTOUB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UISC") )]
	CodeUISC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UIDX") )]
	CodeUIDX,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UINS") )]
	CodeUINS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UIRT") )]
	CodeUIRT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REOU") )]
	CodeREOU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UTYP") )]
	CodeUTYP,
}

impl NonEquitySubClassSegmentationCriteria1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// NonEquitySubClassSegmentationCriterion1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NonEquitySubClassSegmentationCriterion1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CritNm") )]
	pub crit_nm: NonEquitySubClassSegmentationCriteria1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CritVal") )]
	pub crit_val: String,
}

impl NonEquitySubClassSegmentationCriterion1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.crit_nm.validate()?;
		if self.crit_val.chars().count() < 1 {
			return Err(ValidationError::new(1001, "crit_val is shorter than the minimum length of 1".to_string()));
		}
		if self.crit_val.chars().count() > 1000 {
			return Err(ValidationError::new(1002, "crit_val exceeds the maximum length of 1000".to_string()));
		}
		Ok(())
	}
}


// NonFinancialInstitutionSector10 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NonFinancialInstitutionSector10 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sctr") )]
	pub sctr: Vec<GenericIdentification175>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrThrshld", skip_serializing_if = "Option::is_none") )]
	pub clr_thrshld: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DrctlyLkdActvty", skip_serializing_if = "Option::is_none") )]
	pub drctly_lkd_actvty: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FdrlInstn", skip_serializing_if = "Option::is_none") )]
	pub fdrl_instn: Option<bool>,
}

impl NonFinancialInstitutionSector10 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		for item in &self.sctr { item.validate()? }
		Ok(())
	}
}


// NonFinancialPartySector1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum NonFinancialPartySector1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "WTER") )]
	CodeWTER,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MING") )]
	CodeMING,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MAFG") )]
	CodeMAFG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SPLY") )]
	CodeSPLY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CSTR") )]
	CodeCSTR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AGRI") )]
	CodeAGRI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACAF") )]
	CodeACAF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EDUC") )]
	CodeEDUC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AEAR") )]
	CodeAEAR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FINA") )]
	CodeFINA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HHSW") )]
	CodeHHSW,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INCO") )]
	CodeINCO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WRRM") )]
	CodeWRRM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTSA") )]
	CodeOTSA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PSTA") )]
	CodePSTA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PADS") )]
	CodePADS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RESA") )]
	CodeRESA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TRAS") )]
	CodeTRAS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ASSA") )]
	CodeASSA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AHAE") )]
	CodeAHAE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AEOB") )]
	CodeAEOB,
}

impl NonFinancialPartySector1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// NonTradingDayReason1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum NonTradingDayReason1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "THOL") )]
	CodeTHOL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HALF") )]
	CodeHALF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PHOL") )]
	CodePHOL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BHOL") )]
	CodeBHOL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WKND") )]
	CodeWKND,
}

impl NonTradingDayReason1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// NotApplicable1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum NotApplicable1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "NOAP") )]
	CodeNOAP,
}

impl NotApplicable1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// NotAvailable1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum NotAvailable1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "NTAV") )]
	CodeNTAV,
}

impl NotAvailable1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// NotReported1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum NotReported1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "NORP") )]
	CodeNORP,
}

impl NotReported1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Notification2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Notification2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtfctnTp") )]
	pub ntfctn_tp: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Reqrd") )]
	pub reqrd: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DstrbtnTp", skip_serializing_if = "Option::is_none") )]
	pub dstrbtn_tp: Option<InformationDistribution1Choice>,
}

impl Notification2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.ntfctn_tp.chars().count() < 1 {
			return Err(ValidationError::new(1001, "ntfctn_tp is shorter than the minimum length of 1".to_string()));
		}
		if self.ntfctn_tp.chars().count() > 35 {
			return Err(ValidationError::new(1002, "ntfctn_tp exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.dstrbtn_tp { val.validate()? }
		Ok(())
	}
}


// NotificationCancellationReason1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NotificationCancellationReason1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl NotificationCancellationReason1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// NotificationCancellationReason2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NotificationCancellationReason2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Orgtr", skip_serializing_if = "Option::is_none") )]
	pub orgtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<NotificationCancellationReason1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<Vec<String>>,
}

impl NotificationCancellationReason2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgtr { val.validate()? }
		if let Some(ref val) = self.rsn { val.validate()? }
		if let Some(ref vec) = self.addtl_inf {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 105 {
					return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 105".to_string()));
				}
			}
		}
		Ok(())
	}
}


// NotificationItem9 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NotificationItem9 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndToEndId", skip_serializing_if = "Option::is_none") )]
	pub end_to_end_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UETR", skip_serializing_if = "Option::is_none") )]
	pub uetr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Acct", skip_serializing_if = "Option::is_none") )]
	pub acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctOwnr", skip_serializing_if = "Option::is_none") )]
	pub acct_ownr: Option<Party50Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcr", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdAcct", skip_serializing_if = "Option::is_none") )]
	pub rltd_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveOrHistoricCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XpctdValDt", skip_serializing_if = "Option::is_none") )]
	pub xpctd_val_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dbtr", skip_serializing_if = "Option::is_none") )]
	pub dbtr: Option<Party50Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgt", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Purp", skip_serializing_if = "Option::is_none") )]
	pub purp: Option<Purpose2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdRmtInf", skip_serializing_if = "Option::is_none") )]
	pub rltd_rmt_inf: Option<RemittanceLocation8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RmtInf", skip_serializing_if = "Option::is_none") )]
	pub rmt_inf: Option<RemittanceInformation22>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UndrlygAllcn", skip_serializing_if = "Option::is_none") )]
	pub undrlyg_allcn: Option<Vec<TransactionAllocation1>>,
}

impl NotificationItem9 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.end_to_end_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "end_to_end_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "end_to_end_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.uetr {
			let pattern = Regex::new("[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "uetr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.acct { val.validate()? }
		if let Some(ref val) = self.acct_ownr { val.validate()? }
		if let Some(ref val) = self.acct_svcr { val.validate()? }
		if let Some(ref val) = self.rltd_acct { val.validate()? }
		self.amt.validate()?;
		if let Some(ref val) = self.dbtr { val.validate()? }
		if let Some(ref val) = self.dbtr_agt { val.validate()? }
		if let Some(ref val) = self.intrmy_agt { val.validate()? }
		if let Some(ref val) = self.purp { val.validate()? }
		if let Some(ref val) = self.rltd_rmt_inf { val.validate()? }
		if let Some(ref val) = self.rmt_inf { val.validate()? }
		if let Some(ref vec) = self.undrlyg_allcn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// NotificationLocationData1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NotificationLocationData1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mtd") )]
	pub mtd: InvestigationLocationMethod1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ElctrncAdr", skip_serializing_if = "Option::is_none") )]
	pub elctrnc_adr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstlAdr", skip_serializing_if = "Option::is_none") )]
	pub pstl_adr: Option<NameAndAddress18>,
}

impl NotificationLocationData1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.mtd.validate()?;
		if let Some(ref val) = self.elctrnc_adr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "elctrnc_adr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 2048 {
				return Err(ValidationError::new(1002, "elctrnc_adr exceeds the maximum length of 2048".to_string()));
			}
		}
		if let Some(ref val) = self.pstl_adr { val.validate()? }
		Ok(())
	}
}


// NotificationStatus3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum NotificationStatus3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "RCBD") )]
	CodeRCBD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RCVD") )]
	CodeRCVD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NRCD") )]
	CodeNRCD,
}

impl NotificationStatus3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// NotificationSubType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NotificationSubType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl NotificationSubType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// NotificationType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NotificationType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl NotificationType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// NotionalAmount5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NotionalAmount5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<AmountAndDirection106>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SchdlPrd", skip_serializing_if = "Option::is_none") )]
	pub schdl_prd: Option<Vec<Schedule11>>,
}

impl NotionalAmount5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.amt { val.validate()? }
		if let Some(ref vec) = self.schdl_prd { for item in vec { item.validate()? } }
		Ok(())
	}
}


// NotionalAmount6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NotionalAmount6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<AmountAndDirection106>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SchdlPrd", skip_serializing_if = "Option::is_none") )]
	pub schdl_prd: Option<Vec<Schedule11>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ccy", skip_serializing_if = "Option::is_none") )]
	pub ccy: Option<String>,
}

impl NotionalAmount6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.amt { val.validate()? }
		if let Some(ref vec) = self.schdl_prd { for item in vec { item.validate()? } }
		if let Some(ref val) = self.ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ccy does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// NotionalAmount7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NotionalAmount7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<ActiveOrHistoricCurrencyAnd19DecimalAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AmtInFct", skip_serializing_if = "Option::is_none") )]
	pub amt_in_fct: Option<Vec<ActiveOrHistoricCurrencyAnd19DecimalAmount>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WghtdAvrgDlta", skip_serializing_if = "Option::is_none") )]
	pub wghtd_avrg_dlta: Option<f64>,
}

impl NotionalAmount7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.amt { val.validate()? }
		if let Some(ref vec) = self.amt_in_fct { for item in vec { item.validate()? } }
		Ok(())
	}
}


// NotionalAmountLegs5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NotionalAmountLegs5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrstLeg", skip_serializing_if = "Option::is_none") )]
	pub frst_leg: Option<NotionalAmount5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ScndLeg", skip_serializing_if = "Option::is_none") )]
	pub scnd_leg: Option<NotionalAmount6>,
}

impl NotionalAmountLegs5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.frst_leg { val.validate()? }
		if let Some(ref val) = self.scnd_leg { val.validate()? }
		Ok(())
	}
}


// NotionalAmountLegs6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NotionalAmountLegs6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrstLeg", skip_serializing_if = "Option::is_none") )]
	pub frst_leg: Option<NotionalAmount7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ScndLeg", skip_serializing_if = "Option::is_none") )]
	pub scnd_leg: Option<NotionalAmount7>,
}

impl NotionalAmountLegs6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.frst_leg { val.validate()? }
		if let Some(ref val) = self.scnd_leg { val.validate()? }
		Ok(())
	}
}


// NotionalOrUnitBased1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NotionalOrUnitBased1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<NotionalOrUnitBased1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl NotionalOrUnitBased1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// NotionalOrUnitBased1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum NotionalOrUnitBased1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "UNIT") )]
	CodeUNIT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NOTI") )]
	CodeNOTI,
}

impl NotionalOrUnitBased1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// NotionalQuantity9 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NotionalQuantity9 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlQty", skip_serializing_if = "Option::is_none") )]
	pub ttl_qty: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnitOfMeasr", skip_serializing_if = "Option::is_none") )]
	pub unit_of_measr: Option<UnitOfMeasure8Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dtls", skip_serializing_if = "Option::is_none") )]
	pub dtls: Option<QuantityOrTerm1Choice>,
}

impl NotionalQuantity9 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.unit_of_measr { val.validate()? }
		if let Some(ref val) = self.dtls { val.validate()? }
		Ok(())
	}
}


// NotionalQuantityLegs5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NotionalQuantityLegs5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrstLeg", skip_serializing_if = "Option::is_none") )]
	pub frst_leg: Option<NotionalQuantity9>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ScndLeg", skip_serializing_if = "Option::is_none") )]
	pub scnd_leg: Option<NotionalQuantity9>,
}

impl NotionalQuantityLegs5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.frst_leg { val.validate()? }
		if let Some(ref val) = self.scnd_leg { val.validate()? }
		Ok(())
	}
}


// NovationStatus1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum NovationStatus1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "NONO") )]
	CodeNONO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NOVA") )]
	CodeNOVA,
}

impl NovationStatus1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Number3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Number3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Shrt", skip_serializing_if = "Option::is_none") )]
	pub shrt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Lng", skip_serializing_if = "Option::is_none") )]
	pub lng: Option<String>,
}

impl Number3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.shrt {
			let pattern = Regex::new("[0-9]{3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "shrt does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.lng {
			let pattern = Regex::new("[0-9]{5}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "lng does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// NumberAndSumOfTransactions1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NumberAndSumOfTransactions1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfNtries", skip_serializing_if = "Option::is_none") )]
	pub nb_of_ntries: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sum", skip_serializing_if = "Option::is_none") )]
	pub sum: Option<f64>,
}

impl NumberAndSumOfTransactions1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nb_of_ntries {
			let pattern = Regex::new("[0-9]{1,15}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "nb_of_ntries does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// NumberAndSumOfTransactions2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NumberAndSumOfTransactions2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfNtries", skip_serializing_if = "Option::is_none") )]
	pub nb_of_ntries: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sum", skip_serializing_if = "Option::is_none") )]
	pub sum: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNetNtryAmt", skip_serializing_if = "Option::is_none") )]
	pub ttl_net_ntry_amt: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbtInd", skip_serializing_if = "Option::is_none") )]
	pub cdt_dbt_ind: Option<CreditDebitCode>,
}

impl NumberAndSumOfTransactions2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nb_of_ntries {
			let pattern = Regex::new("[0-9]{1,15}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "nb_of_ntries does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.cdt_dbt_ind { val.validate()? }
		Ok(())
	}
}


// NumberAndSumOfTransactions4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NumberAndSumOfTransactions4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfNtries", skip_serializing_if = "Option::is_none") )]
	pub nb_of_ntries: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sum", skip_serializing_if = "Option::is_none") )]
	pub sum: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNetNtry", skip_serializing_if = "Option::is_none") )]
	pub ttl_net_ntry: Option<AmountAndDirection35>,
}

impl NumberAndSumOfTransactions4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nb_of_ntries {
			let pattern = Regex::new("[0-9]{1,15}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "nb_of_ntries does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.ttl_net_ntry { val.validate()? }
		Ok(())
	}
}


// NumberAndVolume2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NumberAndVolume2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nb") )]
	pub nb: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Vol") )]
	pub vol: ActiveOrHistoricCurrencyAndAmount,
}

impl NumberAndVolume2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.vol.validate()?;
		Ok(())
	}
}


// NumberCount1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NumberCount1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CurInstrNb", skip_serializing_if = "Option::is_none") )]
	pub cur_instr_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNb", skip_serializing_if = "Option::is_none") )]
	pub ttl_nb: Option<TotalNumber1>,
}

impl NumberCount1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cur_instr_nb {
			let pattern = Regex::new("[0-9]{3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "cur_instr_nb does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.ttl_nb { val.validate()? }
		Ok(())
	}
}


// NumberModification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NumberModification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModCd", skip_serializing_if = "Option::is_none") )]
	pub mod_cd: Option<Modification1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nb") )]
	pub nb: String,
}

impl NumberModification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mod_cd { val.validate()? }
		let pattern = Regex::new("[0-9]{1,5}").unwrap();
		if !pattern.is_match(&self.nb) {
			return Err(ValidationError::new(1005, "nb does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// NumberOfCancellationsPerStatus1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NumberOfCancellationsPerStatus1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtldNbOfTxs") )]
	pub dtld_nb_of_txs: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtldSts") )]
	pub dtld_sts: CancellationIndividualStatus1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtldCtrlSum", skip_serializing_if = "Option::is_none") )]
	pub dtld_ctrl_sum: Option<f64>,
}

impl NumberOfCancellationsPerStatus1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[0-9]{1,15}").unwrap();
		if !pattern.is_match(&self.dtld_nb_of_txs) {
			return Err(ValidationError::new(1005, "dtld_nb_of_txs does not match the required pattern".to_string()));
		}
		self.dtld_sts.validate()?;
		Ok(())
	}
}


// NumberOfRecordsPerStatus1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NumberOfRecordsPerStatus1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtldNbOfRcrds") )]
	pub dtld_nb_of_rcrds: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtldSts") )]
	pub dtld_sts: ReportingRecordStatus1Code,
}

impl NumberOfRecordsPerStatus1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[0-9]{1,15}").unwrap();
		if !pattern.is_match(&self.dtld_nb_of_rcrds) {
			return Err(ValidationError::new(1005, "dtld_nb_of_rcrds does not match the required pattern".to_string()));
		}
		self.dtld_sts.validate()?;
		Ok(())
	}
}


// NumberOfReportsPerStatus4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NumberOfReportsPerStatus4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtldNbOfRpts") )]
	pub dtld_nb_of_rpts: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtldSts") )]
	pub dtld_sts: PairedReconciled3Code,
}

impl NumberOfReportsPerStatus4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[0-9]{1,15}").unwrap();
		if !pattern.is_match(&self.dtld_nb_of_rpts) {
			return Err(ValidationError::new(1005, "dtld_nb_of_rpts does not match the required pattern".to_string()));
		}
		self.dtld_sts.validate()?;
		Ok(())
	}
}


// NumberOfTransactionsPerStatus1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NumberOfTransactionsPerStatus1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtldNbOfTxs") )]
	pub dtld_nb_of_txs: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtldSts") )]
	pub dtld_sts: TransactionIndividualStatus1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtldCtrlSum", skip_serializing_if = "Option::is_none") )]
	pub dtld_ctrl_sum: Option<f64>,
}

impl NumberOfTransactionsPerStatus1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[0-9]{1,15}").unwrap();
		if !pattern.is_match(&self.dtld_nb_of_txs) {
			return Err(ValidationError::new(1005, "dtld_nb_of_txs does not match the required pattern".to_string()));
		}
		self.dtld_sts.validate()?;
		Ok(())
	}
}


// NumberOfTransactionsPerStatus5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NumberOfTransactionsPerStatus5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtldNbOfTxs") )]
	pub dtld_nb_of_txs: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtldSts") )]
	pub dtld_sts: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtldCtrlSum", skip_serializing_if = "Option::is_none") )]
	pub dtld_ctrl_sum: Option<f64>,
}

impl NumberOfTransactionsPerStatus5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[0-9]{1,15}").unwrap();
		if !pattern.is_match(&self.dtld_nb_of_txs) {
			return Err(ValidationError::new(1005, "dtld_nb_of_txs does not match the required pattern".to_string()));
		}
		if self.dtld_sts.chars().count() < 1 {
			return Err(ValidationError::new(1001, "dtld_sts is shorter than the minimum length of 1".to_string()));
		}
		if self.dtld_sts.chars().count() > 4 {
			return Err(ValidationError::new(1002, "dtld_sts exceeds the maximum length of 4".to_string()));
		}
		Ok(())
	}
}


// NumberOfTransactionsPerValidationRule5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NumberOfTransactionsPerValidationRule5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtldNb") )]
	pub dtld_nb: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptSts") )]
	pub rpt_sts: Vec<RejectionReason45>,
}

impl NumberOfTransactionsPerValidationRule5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[0-9]{1,15}").unwrap();
		if !pattern.is_match(&self.dtld_nb) {
			return Err(ValidationError::new(1005, "dtld_nb does not match the required pattern".to_string()));
		}
		for item in &self.rpt_sts { item.validate()? }
		Ok(())
	}
}


// NumberOfTransactionsPerValidationRule6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct NumberOfTransactionsPerValidationRule6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtldNb") )]
	pub dtld_nb: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptSts") )]
	pub rpt_sts: Vec<RejectionReason70>,
}

impl NumberOfTransactionsPerValidationRule6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[0-9]{1,15}").unwrap();
		if !pattern.is_match(&self.dtld_nb) {
			return Err(ValidationError::new(1005, "dtld_nb does not match the required pattern".to_string()));
		}
		for item in &self.rpt_sts { item.validate()? }
		Ok(())
	}
}


// OnLineCapability1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum OnLineCapability1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "OFLN") )]
	CodeOFLN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ONLN") )]
	CodeONLN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SMON") )]
	CodeSMON,
}

impl OnLineCapability1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// OpenInterest1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OpenInterest1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "GrssNtnlAmt") )]
	pub grss_ntnl_amt: ActiveCurrencyAnd24Amount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfLots", skip_serializing_if = "Option::is_none") )]
	pub nb_of_lots: Option<f64>,
}

impl OpenInterest1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.grss_ntnl_amt.validate()?;
		if let Some(ref val) = self.nb_of_lots {
			if *val < 1.000000 {
				return Err(ValidationError::new(1003, "nb_of_lots is less than the minimum value of 1.000000".to_string()));
			}
		}
		Ok(())
	}
}


// Operation1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum Operation1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "TILL") )]
	CodeTILL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ORRR") )]
	CodeORRR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ANDD") )]
	CodeANDD,
}

impl Operation1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Operation3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum Operation3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ANDD") )]
	CodeANDD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ORRR") )]
	CodeORRR,
}

impl Operation3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// OperationMandate6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OperationMandate6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModCd", skip_serializing_if = "Option::is_none") )]
	pub mod_cd: Option<Modification1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AplblChanl") )]
	pub aplbl_chanl: Vec<Channel2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqrdSgntrNb") )]
	pub reqrd_sgntr_nb: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SgntrOrdrInd") )]
	pub sgntr_ordr_ind: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MndtHldr", skip_serializing_if = "Option::is_none") )]
	pub mndt_hldr: Option<Vec<PartyAndAuthorisation6>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BkOpr") )]
	pub bk_opr: Vec<BankTransactionCodeStructure4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StartDt", skip_serializing_if = "Option::is_none") )]
	pub start_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndDt", skip_serializing_if = "Option::is_none") )]
	pub end_dt: Option<String>,
}

impl OperationMandate6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mod_cd { val.validate()? }
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		for item in &self.aplbl_chanl { item.validate()? }
		let pattern = Regex::new("[\\+]{0,1}[0-9]{1,15}").unwrap();
		if !pattern.is_match(&self.reqrd_sgntr_nb) {
			return Err(ValidationError::new(1005, "reqrd_sgntr_nb does not match the required pattern".to_string()));
		}
		if let Some(ref vec) = self.mndt_hldr { for item in vec { item.validate()? } }
		for item in &self.bk_opr { item.validate()? }
		Ok(())
	}
}


// OperationMandate7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OperationMandate7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AplblChanl") )]
	pub aplbl_chanl: Vec<Channel2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqrdSgntrNb") )]
	pub reqrd_sgntr_nb: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SgntrOrdrInd") )]
	pub sgntr_ordr_ind: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MndtHldr", skip_serializing_if = "Option::is_none") )]
	pub mndt_hldr: Option<Vec<PartyAndAuthorisation7>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BkOpr") )]
	pub bk_opr: Vec<BankTransactionCodeStructure4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StartDt", skip_serializing_if = "Option::is_none") )]
	pub start_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndDt", skip_serializing_if = "Option::is_none") )]
	pub end_dt: Option<String>,
}

impl OperationMandate7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		for item in &self.aplbl_chanl { item.validate()? }
		let pattern = Regex::new("[\\+]{0,1}[0-9]{1,15}").unwrap();
		if !pattern.is_match(&self.reqrd_sgntr_nb) {
			return Err(ValidationError::new(1005, "reqrd_sgntr_nb does not match the required pattern".to_string()));
		}
		if let Some(ref vec) = self.mndt_hldr { for item in vec { item.validate()? } }
		for item in &self.bk_opr { item.validate()? }
		Ok(())
	}
}


// OperationalStatus1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum OperationalStatus1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ENAB") )]
	CodeENAB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SPEC") )]
	CodeSPEC,
}

impl OperationalStatus1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Operator1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum Operator1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "SMAL") )]
	CodeSMAL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SMEQ") )]
	CodeSMEQ,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GREA") )]
	CodeGREA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GREQ") )]
	CodeGREQ,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EQAL") )]
	CodeEQAL,
}

impl Operator1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Option12 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Option12 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: OptionType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtOrPrd") )]
	pub dt_or_prd: OptionDateOrPeriod1Choice,
}

impl Option12 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tp.validate()?;
		self.dt_or_prd.validate()?;
		Ok(())
	}
}


// Option14 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Option14 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "XprtnStyle") )]
	pub xprtn_style: Vec<OptionStyle5Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OptnStyle", skip_serializing_if = "Option::is_none") )]
	pub optn_style: Option<ExoticOptionStyle1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OptnTp", skip_serializing_if = "Option::is_none") )]
	pub optn_tp: Option<OptionType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BrrrInd", skip_serializing_if = "Option::is_none") )]
	pub brrr_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EvtTp", skip_serializing_if = "Option::is_none") )]
	pub evt_tp: Option<OptionEvent2>,
}

impl Option14 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		for item in &self.xprtn_style { item.validate()? }
		if let Some(ref val) = self.optn_style { val.validate()? }
		if let Some(ref val) = self.optn_tp { val.validate()? }
		if let Some(ref val) = self.evt_tp { val.validate()? }
		Ok(())
	}
}


// Option15 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Option15 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OptnSttlmStyle", skip_serializing_if = "Option::is_none") )]
	pub optn_sttlm_style: Option<SettleStyle2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ConvsDt", skip_serializing_if = "Option::is_none") )]
	pub convs_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StrkPric", skip_serializing_if = "Option::is_none") )]
	pub strk_pric: Option<Price8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MinExrcblQty", skip_serializing_if = "Option::is_none") )]
	pub min_exrcbl_qty: Option<FinancialInstrumentQuantity1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ConvsPrd", skip_serializing_if = "Option::is_none") )]
	pub convs_prd: Option<DateTimePeriod1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OptnStyle", skip_serializing_if = "Option::is_none") )]
	pub optn_style: Option<OptionStyle1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OptnTp", skip_serializing_if = "Option::is_none") )]
	pub optn_tp: Option<OptionType8Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StrkVal", skip_serializing_if = "Option::is_none") )]
	pub strk_val: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StrkMltplr", skip_serializing_if = "Option::is_none") )]
	pub strk_mltplr: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrmAssgnmtMtd", skip_serializing_if = "Option::is_none") )]
	pub instrm_assgnmt_mtd: Option<AssignmentMethod2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VrsnNb", skip_serializing_if = "Option::is_none") )]
	pub vrsn_nb: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XpryLctn", skip_serializing_if = "Option::is_none") )]
	pub xpry_lctn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Stdstn", skip_serializing_if = "Option::is_none") )]
	pub stdstn: Option<Standardisation3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgPtyRole", skip_serializing_if = "Option::is_none") )]
	pub tradg_pty_role: Option<OptionParty3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctSz", skip_serializing_if = "Option::is_none") )]
	pub ctrct_sz: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlUndrlygAttrbts", skip_serializing_if = "Option::is_none") )]
	pub addtl_undrlyg_attrbts: Option<Vec<UnderlyingAttributes4>>,
}

impl Option15 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.optn_sttlm_style { val.validate()? }
		if let Some(ref val) = self.strk_pric { val.validate()? }
		if let Some(ref val) = self.min_exrcbl_qty { val.validate()? }
		if let Some(ref val) = self.convs_prd { val.validate()? }
		if let Some(ref val) = self.optn_style { val.validate()? }
		if let Some(ref val) = self.optn_tp { val.validate()? }
		if let Some(ref val) = self.instrm_assgnmt_mtd { val.validate()? }
		if let Some(ref val) = self.xpry_lctn {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "xpry_lctn is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "xpry_lctn exceeds the maximum length of 4".to_string()));
			}
			let pattern = Regex::new("[a-zA-Z0-9]{1,4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "xpry_lctn does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.stdstn { val.validate()? }
		if let Some(ref val) = self.tradg_pty_role { val.validate()? }
		if let Some(ref vec) = self.addtl_undrlyg_attrbts { for item in vec { item.validate()? } }
		Ok(())
	}
}


// OptionBarrierLevel1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OptionBarrierLevel1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sngl", skip_serializing_if = "Option::is_none") )]
	pub sngl: Option<SecuritiesTransactionPrice23Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mltpl", skip_serializing_if = "Option::is_none") )]
	pub mltpl: Option<OptionMultipleBarrierLevels1>,
}

impl OptionBarrierLevel1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.sngl { val.validate()? }
		if let Some(ref val) = self.mltpl { val.validate()? }
		Ok(())
	}
}


// OptionDateOrPeriod1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OptionDateOrPeriod1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "EarlstExrcDt", skip_serializing_if = "Option::is_none") )]
	pub earlst_exrc_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtcePrd", skip_serializing_if = "Option::is_none") )]
	pub ntce_prd: Option<f64>,
}

impl OptionDateOrPeriod1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// OptionEvent2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OptionEvent2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: OptionEventType1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Desc") )]
	pub desc: String,
}

impl OptionEvent2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tp.validate()?;
		if self.desc.chars().count() < 1 {
			return Err(ValidationError::new(1001, "desc is shorter than the minimum length of 1".to_string()));
		}
		if self.desc.chars().count() > 35 {
			return Err(ValidationError::new(1002, "desc exceeds the maximum length of 35".to_string()));
		}
		Ok(())
	}
}


// OptionEventType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OptionEventType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<OptionEventType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification36>,
}

impl OptionEventType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// OptionEventType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum OptionEventType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CLST") )]
	CodeCLST,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CONF") )]
	CodeCONF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "KNIN") )]
	CodeKNIN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "KNOC") )]
	CodeKNOC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TRIG") )]
	CodeTRIG,
}

impl OptionEventType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// OptionMultipleBarrierLevels1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OptionMultipleBarrierLevels1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "LwrLvl") )]
	pub lwr_lvl: SecuritiesTransactionPrice23Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UpperLvl") )]
	pub upper_lvl: SecuritiesTransactionPrice23Choice,
}

impl OptionMultipleBarrierLevels1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.lwr_lvl.validate()?;
		self.upper_lvl.validate()?;
		Ok(())
	}
}


// OptionOrSwaption11 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OptionOrSwaption11 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<OptionType2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MbddTp", skip_serializing_if = "Option::is_none") )]
	pub mbdd_tp: Option<EmbeddedType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExrcStyle", skip_serializing_if = "Option::is_none") )]
	pub exrc_style: Option<Vec<OptionStyle6Code>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExrcDt", skip_serializing_if = "Option::is_none") )]
	pub exrc_dt: Option<ExerciseDate1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StrkPric", skip_serializing_if = "Option::is_none") )]
	pub strk_pric: Option<SecuritiesTransactionPrice17Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StrkPricSchdl", skip_serializing_if = "Option::is_none") )]
	pub strk_pric_schdl: Option<Vec<Schedule4>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CallAmt", skip_serializing_if = "Option::is_none") )]
	pub call_amt: Option<ActiveOrHistoricCurrencyAnd19DecimalAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PutAmt", skip_serializing_if = "Option::is_none") )]
	pub put_amt: Option<ActiveOrHistoricCurrencyAnd19DecimalAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrmAmt", skip_serializing_if = "Option::is_none") )]
	pub prm_amt: Option<ActiveOrHistoricCurrencyAnd19DecimalAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrmPmtDt", skip_serializing_if = "Option::is_none") )]
	pub prm_pmt_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MtrtyDtOfUndrlyg", skip_serializing_if = "Option::is_none") )]
	pub mtrty_dt_of_undrlyg: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BrrrLvls", skip_serializing_if = "Option::is_none") )]
	pub brrr_lvls: Option<OptionBarrierLevel1Choice>,
}

impl OptionOrSwaption11 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.mbdd_tp { val.validate()? }
		if let Some(ref vec) = self.exrc_style { for item in vec { item.validate()? } }
		if let Some(ref val) = self.exrc_dt { val.validate()? }
		if let Some(ref val) = self.strk_pric { val.validate()? }
		if let Some(ref vec) = self.strk_pric_schdl { for item in vec { item.validate()? } }
		if let Some(ref val) = self.call_amt { val.validate()? }
		if let Some(ref val) = self.put_amt { val.validate()? }
		if let Some(ref val) = self.prm_amt { val.validate()? }
		if let Some(ref val) = self.brrr_lvls { val.validate()? }
		Ok(())
	}
}


// OptionParty1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum OptionParty1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "SLLR") )]
	CodeSLLR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BYER") )]
	CodeBYER,
}

impl OptionParty1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// OptionParty3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OptionParty3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<Vec<OptionParty1Code>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl OptionParty3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.cd { for item in vec { item.validate()? } }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// OptionParty3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum OptionParty3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "MAKE") )]
	CodeMAKE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TAKE") )]
	CodeTAKE,
}

impl OptionParty3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// OptionStyle1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OptionStyle1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<OptionStyle1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification13>,
}

impl OptionStyle1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// OptionStyle1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum OptionStyle1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "AMER") )]
	CodeAMER,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EURO") )]
	CodeEURO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BERM") )]
	CodeBERM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ASIA") )]
	CodeASIA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CANA") )]
	CodeCANA,
}

impl OptionStyle1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// OptionStyle5Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum OptionStyle5Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "AMER") )]
	CodeAMER,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ASIA") )]
	CodeASIA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BERM") )]
	CodeBERM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EURO") )]
	CodeEURO,
}

impl OptionStyle5Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// OptionStyle6Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum OptionStyle6Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "EURO") )]
	CodeEURO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BERM") )]
	CodeBERM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ASIA") )]
	CodeASIA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AMER") )]
	CodeAMER,
}

impl OptionStyle6Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// OptionStyle7Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum OptionStyle7Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "AMER") )]
	CodeAMER,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ASIA") )]
	CodeASIA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BERM") )]
	CodeBERM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EURO") )]
	CodeEURO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
}

impl OptionStyle7Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// OptionType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum OptionType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CALL") )]
	CodeCALL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PUTO") )]
	CodePUTO,
}

impl OptionType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// OptionType2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum OptionType2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CALL") )]
	CodeCALL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PUTO") )]
	CodePUTO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
}

impl OptionType2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// OptionType8Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OptionType8Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<Vec<OptionType1Code>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl OptionType8Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.cd { for item in vec { item.validate()? } }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// OrderClassification2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OrderClassification2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrdrTp", skip_serializing_if = "Option::is_none") )]
	pub ordr_tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrdrTpClssfctn", skip_serializing_if = "Option::is_none") )]
	pub ordr_tp_clssfctn: Option<OrderType3Code>,
}

impl OrderClassification2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ordr_tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ordr_tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 50 {
				return Err(ValidationError::new(1002, "ordr_tp exceeds the maximum length of 50".to_string()));
			}
		}
		if let Some(ref val) = self.ordr_tp_clssfctn { val.validate()? }
		Ok(())
	}
}


// OrderData3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OrderData3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrdrIdData") )]
	pub ordr_id_data: OrderIdentification2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AuctnData", skip_serializing_if = "Option::is_none") )]
	pub auctn_data: Option<AuctionData2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrdrData", skip_serializing_if = "Option::is_none") )]
	pub ordr_data: Option<OrderData4>,
}

impl OrderData3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.ordr_id_data.validate()?;
		if let Some(ref val) = self.auctn_data { val.validate()? }
		if let Some(ref val) = self.ordr_data { val.validate()? }
		Ok(())
	}
}


// OrderData4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OrderData4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubmitgNtty", skip_serializing_if = "Option::is_none") )]
	pub submitg_ntty: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DrctElctrncAccs", skip_serializing_if = "Option::is_none") )]
	pub drct_elctrnc_accs: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClntId", skip_serializing_if = "Option::is_none") )]
	pub clnt_id: Option<PersonOrOrganisation4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstmtDcsnPrsn", skip_serializing_if = "Option::is_none") )]
	pub invstmt_dcsn_prsn: Option<ExecutingParty2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExctgPrsn", skip_serializing_if = "Option::is_none") )]
	pub exctg_prsn: Option<ExecutingParty2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NonExctgBrkr", skip_serializing_if = "Option::is_none") )]
	pub non_exctg_brkr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgCpcty", skip_serializing_if = "Option::is_none") )]
	pub tradg_cpcty: Option<RegulatoryTradingCapacity1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LqdtyPrvsnActvty", skip_serializing_if = "Option::is_none") )]
	pub lqdty_prvsn_actvty: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrdrClssfctn", skip_serializing_if = "Option::is_none") )]
	pub ordr_clssfctn: Option<OrderClassification2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrdrPrics", skip_serializing_if = "Option::is_none") )]
	pub ordr_prics: Option<OrderPriceData2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrData", skip_serializing_if = "Option::is_none") )]
	pub instr_data: Option<OrderInstructionData2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxData", skip_serializing_if = "Option::is_none") )]
	pub tx_data: Option<TransactionData3>,
}

impl OrderData4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.submitg_ntty {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "submitg_ntty does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.clnt_id { val.validate()? }
		if let Some(ref val) = self.invstmt_dcsn_prsn { val.validate()? }
		if let Some(ref val) = self.exctg_prsn { val.validate()? }
		if let Some(ref val) = self.non_exctg_brkr {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "non_exctg_brkr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.tradg_cpcty { val.validate()? }
		if let Some(ref val) = self.ordr_clssfctn { val.validate()? }
		if let Some(ref val) = self.ordr_prics { val.validate()? }
		if let Some(ref val) = self.instr_data { val.validate()? }
		if let Some(ref val) = self.tx_data { val.validate()? }
		Ok(())
	}
}


// OrderDesk1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OrderDesk1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrdrDsk", skip_serializing_if = "Option::is_none") )]
	pub ordr_dsk: Option<ContactAttributes5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClsrDts", skip_serializing_if = "Option::is_none") )]
	pub clsr_dts: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<Vec<AdditionalInformation15>>,
}

impl OrderDesk1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ordr_dsk { val.validate()? }
		if let Some(ref vec) = self.addtl_inf { for item in vec { item.validate()? } }
		Ok(())
	}
}


// OrderEventType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OrderEventType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<OrderEventType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl OrderEventType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// OrderEventType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum OrderEventType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CAME") )]
	CodeCAME,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CAMO") )]
	CodeCAMO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CHME") )]
	CodeCHME,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CHMO") )]
	CodeCHMO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EXPI") )]
	CodeEXPI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FILL") )]
	CodeFILL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NEWO") )]
	CodeNEWO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PARF") )]
	CodePARF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REMA") )]
	CodeREMA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REMO") )]
	CodeREMO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REMH") )]
	CodeREMH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REME") )]
	CodeREME,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TRIG") )]
	CodeTRIG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RFQS") )]
	CodeRFQS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RFQR") )]
	CodeRFQR,
}

impl OrderEventType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// OrderIdentification2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OrderIdentification2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrdrBookId") )]
	pub ordr_book_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SeqNb") )]
	pub seq_nb: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prty", skip_serializing_if = "Option::is_none") )]
	pub prty: Option<OrderPriority1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TmStmp") )]
	pub tm_stmp: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradVn") )]
	pub trad_vn: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrm") )]
	pub fin_instrm: FinancialInstrument99Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrdrId", skip_serializing_if = "Option::is_none") )]
	pub ordr_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtOfRct", skip_serializing_if = "Option::is_none") )]
	pub dt_of_rct: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldtyPrd", skip_serializing_if = "Option::is_none") )]
	pub vldty_prd: Option<ValidityPeriod1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrdrRstrctn", skip_serializing_if = "Option::is_none") )]
	pub ordr_rstrctn: Option<Vec<OrderRestriction1Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldtyDtTm", skip_serializing_if = "Option::is_none") )]
	pub vldty_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EvtTp", skip_serializing_if = "Option::is_none") )]
	pub evt_tp: Option<OrderEventType1Choice>,
}

impl OrderIdentification2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.ordr_book_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "ordr_book_id is shorter than the minimum length of 1".to_string()));
		}
		if self.ordr_book_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "ordr_book_id exceeds the maximum length of 35".to_string()));
		}
		if self.seq_nb < 1.000000 {
			return Err(ValidationError::new(1003, "seq_nb is less than the minimum value of 1.000000".to_string()));
		}
		if let Some(ref val) = self.prty { val.validate()? }
		let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
		if !pattern.is_match(&self.trad_vn) {
			return Err(ValidationError::new(1005, "trad_vn does not match the required pattern".to_string()));
		}
		self.fin_instrm.validate()?;
		if let Some(ref val) = self.ordr_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ordr_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 50 {
				return Err(ValidationError::new(1002, "ordr_id exceeds the maximum length of 50".to_string()));
			}
		}
		if let Some(ref val) = self.vldty_prd { val.validate()? }
		if let Some(ref vec) = self.ordr_rstrctn { for item in vec { item.validate()? } }
		if let Some(ref val) = self.evt_tp { val.validate()? }
		Ok(())
	}
}


// OrderInstructionData2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OrderInstructionData2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BuySellInd", skip_serializing_if = "Option::is_none") )]
	pub buy_sell_ind: Option<Side6Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrdrVldtySts", skip_serializing_if = "Option::is_none") )]
	pub ordr_vldty_sts: Option<OrderStatus10Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrdrSts", skip_serializing_if = "Option::is_none") )]
	pub ordr_sts: Option<Vec<OrderStatus11Code>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitlQty", skip_serializing_if = "Option::is_none") )]
	pub initl_qty: Option<FinancialInstrumentQuantity25Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RmngQty", skip_serializing_if = "Option::is_none") )]
	pub rmng_qty: Option<FinancialInstrumentQuantity25Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DispdQty", skip_serializing_if = "Option::is_none") )]
	pub dispd_qty: Option<FinancialInstrumentQuantity25Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MinAccptblQty", skip_serializing_if = "Option::is_none") )]
	pub min_accptbl_qty: Option<FinancialInstrumentQuantity25Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MinExctbl", skip_serializing_if = "Option::is_none") )]
	pub min_exctbl: Option<MinimumExecutable1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PssvOnlyInd", skip_serializing_if = "Option::is_none") )]
	pub pssv_only_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SlfExctnPrvntn", skip_serializing_if = "Option::is_none") )]
	pub slf_exctn_prvntn: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RtgStrtgy", skip_serializing_if = "Option::is_none") )]
	pub rtg_strtgy: Option<String>,
}

impl OrderInstructionData2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.buy_sell_ind { val.validate()? }
		if let Some(ref val) = self.ordr_vldty_sts { val.validate()? }
		if let Some(ref vec) = self.ordr_sts { for item in vec { item.validate()? } }
		if let Some(ref val) = self.initl_qty { val.validate()? }
		if let Some(ref val) = self.rmng_qty { val.validate()? }
		if let Some(ref val) = self.dispd_qty { val.validate()? }
		if let Some(ref val) = self.min_accptbl_qty { val.validate()? }
		if let Some(ref val) = self.min_exctbl { val.validate()? }
		if let Some(ref val) = self.rtg_strtgy {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rtg_strtgy is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 50 {
				return Err(ValidationError::new(1002, "rtg_strtgy exceeds the maximum length of 50".to_string()));
			}
		}
		Ok(())
	}
}


// OrderOriginatorEligibility1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum OrderOriginatorEligibility1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ELIG") )]
	CodeELIG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RETL") )]
	CodeRETL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PROF") )]
	CodePROF,
}

impl OrderOriginatorEligibility1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// OrderPriceData2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OrderPriceData2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "LmtPric", skip_serializing_if = "Option::is_none") )]
	pub lmt_pric: Option<SecuritiesTransactionPrice2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StopPric", skip_serializing_if = "Option::is_none") )]
	pub stop_pric: Option<SecuritiesTransactionPrice2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlLmtPric", skip_serializing_if = "Option::is_none") )]
	pub addtl_lmt_pric: Option<SecuritiesTransactionPrice2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PggdPric", skip_serializing_if = "Option::is_none") )]
	pub pggd_pric: Option<SecuritiesTransactionPrice2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CcyScndLeg", skip_serializing_if = "Option::is_none") )]
	pub ccy_scnd_leg: Option<String>,
}

impl OrderPriceData2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.lmt_pric { val.validate()? }
		if let Some(ref val) = self.stop_pric { val.validate()? }
		if let Some(ref val) = self.addtl_lmt_pric { val.validate()? }
		if let Some(ref val) = self.pggd_pric { val.validate()? }
		if let Some(ref val) = self.ccy_scnd_leg {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ccy_scnd_leg does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// OrderPriority1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OrderPriority1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TmStmp", skip_serializing_if = "Option::is_none") )]
	pub tm_stmp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sz", skip_serializing_if = "Option::is_none") )]
	pub sz: Option<f64>,
}

impl OrderPriority1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.sz {
			if *val < 1.000000 {
				return Err(ValidationError::new(1003, "sz is less than the minimum value of 1.000000".to_string()));
			}
		}
		Ok(())
	}
}


// OrderQuantityType2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum OrderQuantityType2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "UNIT") )]
	CodeUNIT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CASH") )]
	CodeCASH,
}

impl OrderQuantityType2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// OrderReport2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OrderReport2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "New", skip_serializing_if = "Option::is_none") )]
	pub new: Option<NewOrderReport2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cxl", skip_serializing_if = "Option::is_none") )]
	pub cxl: Option<CancelOrderReport1>,
}

impl OrderReport2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.new { val.validate()? }
		if let Some(ref val) = self.cxl { val.validate()? }
		Ok(())
	}
}


// OrderRestriction1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OrderRestriction1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrdrRstrctnCd", skip_serializing_if = "Option::is_none") )]
	pub ordr_rstrctn_cd: Option<OrderRestrictionType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl OrderRestriction1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ordr_rstrctn_cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// OrderRestrictionType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum OrderRestrictionType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "SESR") )]
	CodeSESR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VFAR") )]
	CodeVFAR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VFCR") )]
	CodeVFCR,
}

impl OrderRestrictionType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// OrderStatus10Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum OrderStatus10Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACTI") )]
	CodeACTI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INAC") )]
	CodeINAC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SUSP") )]
	CodeSUSP,
}

impl OrderStatus10Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// OrderStatus11Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum OrderStatus11Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "FIRM") )]
	CodeFIRM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IMPL") )]
	CodeIMPL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INDI") )]
	CodeINDI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ROUT") )]
	CodeROUT,
}

impl OrderStatus11Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// OrderType3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum OrderType3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "LMTO") )]
	CodeLMTO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "STOP") )]
	CodeSTOP,
}

impl OrderType3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Organisation23 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Organisation23 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm") )]
	pub nm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ShrtNm", skip_serializing_if = "Option::is_none") )]
	pub shrt_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstlAdr") )]
	pub pstl_adr: Vec<PostalAddress21>,
}

impl Organisation23 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
		}
		if self.nm.chars().count() > 350 {
			return Err(ValidationError::new(1002, "nm exceeds the maximum length of 350".to_string()));
		}
		if let Some(ref val) = self.shrt_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "shrt_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "shrt_nm exceeds the maximum length of 35".to_string()));
			}
		}
		for item in &self.pstl_adr { item.validate()? }
		Ok(())
	}
}


// Organisation38 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Organisation38 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm") )]
	pub nm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<PartyIdentification177Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Purp", skip_serializing_if = "Option::is_none") )]
	pub purp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxtnCtry", skip_serializing_if = "Option::is_none") )]
	pub taxtn_ctry: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegnCtry", skip_serializing_if = "Option::is_none") )]
	pub regn_ctry: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegnDt", skip_serializing_if = "Option::is_none") )]
	pub regn_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxIdNb", skip_serializing_if = "Option::is_none") )]
	pub tax_id_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtlRegnNb", skip_serializing_if = "Option::is_none") )]
	pub ntl_regn_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstlAdr") )]
	pub pstl_adr: Vec<PostalAddress3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmryComAdr", skip_serializing_if = "Option::is_none") )]
	pub pmry_com_adr: Option<CommunicationAddress3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ScndryComAdr", skip_serializing_if = "Option::is_none") )]
	pub scndry_com_adr: Option<CommunicationAddress3>,
}

impl Organisation38 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
		}
		if self.nm.chars().count() > 140 {
			return Err(ValidationError::new(1002, "nm exceeds the maximum length of 140".to_string()));
		}
		if let Some(ref val) = self.id { val.validate()? }
		if let Some(ref val) = self.purp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "purp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "purp exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.taxtn_ctry {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "taxtn_ctry does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.regn_ctry {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "regn_ctry does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.tax_id_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tax_id_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tax_id_nb exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.ntl_regn_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ntl_regn_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "ntl_regn_nb exceeds the maximum length of 35".to_string()));
			}
		}
		for item in &self.pstl_adr { item.validate()? }
		if let Some(ref val) = self.pmry_com_adr { val.validate()? }
		if let Some(ref val) = self.scndry_com_adr { val.validate()? }
		Ok(())
	}
}


// Organisation39 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Organisation39 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ShrtNm", skip_serializing_if = "Option::is_none") )]
	pub shrt_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<PartyIdentification177Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LglNttyIdr", skip_serializing_if = "Option::is_none") )]
	pub lgl_ntty_idr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Purp", skip_serializing_if = "Option::is_none") )]
	pub purp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegnCtry", skip_serializing_if = "Option::is_none") )]
	pub regn_ctry: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegnDt", skip_serializing_if = "Option::is_none") )]
	pub regn_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstlAdr", skip_serializing_if = "Option::is_none") )]
	pub pstl_adr: Option<Vec<PostalAddress21>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TpOfOrg", skip_serializing_if = "Option::is_none") )]
	pub tp_of_org: Option<OrganisationType1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PlcOfListg", skip_serializing_if = "Option::is_none") )]
	pub plc_of_listg: Option<Vec<String>>,
}

impl Organisation39 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.shrt_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "shrt_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "shrt_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.id { val.validate()? }
		if let Some(ref val) = self.lgl_ntty_idr {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "lgl_ntty_idr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.purp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "purp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "purp exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.regn_ctry {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "regn_ctry does not match the required pattern".to_string()));
			}
		}
		if let Some(ref vec) = self.pstl_adr { for item in vec { item.validate()? } }
		if let Some(ref val) = self.tp_of_org { val.validate()? }
		if let Some(ref vec) = self.plc_of_listg {
			for item in vec {
				let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
				if !pattern.is_match(&item) {
					return Err(ValidationError::new(1005, "plc_of_listg does not match the required pattern".to_string()));
				}
			}
		}
		Ok(())
	}
}


// Organisation40 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Organisation40 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ShrtNm", skip_serializing_if = "Option::is_none") )]
	pub shrt_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<PartyIdentification177Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LglNttyIdr", skip_serializing_if = "Option::is_none") )]
	pub lgl_ntty_idr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Purp", skip_serializing_if = "Option::is_none") )]
	pub purp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegnCtry", skip_serializing_if = "Option::is_none") )]
	pub regn_ctry: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegnDt", skip_serializing_if = "Option::is_none") )]
	pub regn_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModfdPstlAdr", skip_serializing_if = "Option::is_none") )]
	pub modfd_pstl_adr: Option<Vec<ModificationScope34>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TpOfOrg", skip_serializing_if = "Option::is_none") )]
	pub tp_of_org: Option<OrganisationType1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PlcOfListg", skip_serializing_if = "Option::is_none") )]
	pub plc_of_listg: Option<Vec<String>>,
}

impl Organisation40 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.shrt_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "shrt_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "shrt_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.id { val.validate()? }
		if let Some(ref val) = self.lgl_ntty_idr {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "lgl_ntty_idr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.purp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "purp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "purp exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.regn_ctry {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "regn_ctry does not match the required pattern".to_string()));
			}
		}
		if let Some(ref vec) = self.modfd_pstl_adr { for item in vec { item.validate()? } }
		if let Some(ref val) = self.tp_of_org { val.validate()? }
		if let Some(ref vec) = self.plc_of_listg {
			for item in vec {
				let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
				if !pattern.is_match(&item) {
					return Err(ValidationError::new(1005, "plc_of_listg does not match the required pattern".to_string()));
				}
			}
		}
		Ok(())
	}
}


// Organisation42 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Organisation42 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FullLglNm") )]
	pub full_lgl_nm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgNm", skip_serializing_if = "Option::is_none") )]
	pub tradg_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtryOfOpr") )]
	pub ctry_of_opr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegnDt", skip_serializing_if = "Option::is_none") )]
	pub regn_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OprlAdr", skip_serializing_if = "Option::is_none") )]
	pub oprl_adr: Option<PostalAddress27>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizAdr", skip_serializing_if = "Option::is_none") )]
	pub biz_adr: Option<PostalAddress27>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LglAdr") )]
	pub lgl_adr: PostalAddress27,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BllgAdr", skip_serializing_if = "Option::is_none") )]
	pub bllg_adr: Option<PostalAddress27>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgId") )]
	pub org_id: OrganisationIdentification39,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RprtvOffcr", skip_serializing_if = "Option::is_none") )]
	pub rprtv_offcr: Option<Vec<PartyIdentification274>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrsrMgr", skip_serializing_if = "Option::is_none") )]
	pub trsr_mgr: Option<PartyIdentification274>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MainMndtHldr", skip_serializing_if = "Option::is_none") )]
	pub main_mndt_hldr: Option<Vec<PartyIdentification274>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sndr", skip_serializing_if = "Option::is_none") )]
	pub sndr: Option<Vec<PartyIdentification274>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LglRprtv", skip_serializing_if = "Option::is_none") )]
	pub lgl_rprtv: Option<Vec<PartyIdentification274>>,
}

impl Organisation42 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.full_lgl_nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "full_lgl_nm is shorter than the minimum length of 1".to_string()));
		}
		if self.full_lgl_nm.chars().count() > 350 {
			return Err(ValidationError::new(1002, "full_lgl_nm exceeds the maximum length of 350".to_string()));
		}
		if let Some(ref val) = self.tradg_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tradg_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "tradg_nm exceeds the maximum length of 350".to_string()));
			}
		}
		let pattern = Regex::new("[A-Z]{2,2}").unwrap();
		if !pattern.is_match(&self.ctry_of_opr) {
			return Err(ValidationError::new(1005, "ctry_of_opr does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.oprl_adr { val.validate()? }
		if let Some(ref val) = self.biz_adr { val.validate()? }
		self.lgl_adr.validate()?;
		if let Some(ref val) = self.bllg_adr { val.validate()? }
		self.org_id.validate()?;
		if let Some(ref vec) = self.rprtv_offcr { for item in vec { item.validate()? } }
		if let Some(ref val) = self.trsr_mgr { val.validate()? }
		if let Some(ref vec) = self.main_mndt_hldr { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.sndr { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.lgl_rprtv { for item in vec { item.validate()? } }
		Ok(())
	}
}


// Organisation43 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Organisation43 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FullLglNm") )]
	pub full_lgl_nm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgNm", skip_serializing_if = "Option::is_none") )]
	pub tradg_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgLglSts", skip_serializing_if = "Option::is_none") )]
	pub org_lgl_sts: Option<OrganisationLegalStatus1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EstblishdDt", skip_serializing_if = "Option::is_none") )]
	pub estblishd_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegnNb", skip_serializing_if = "Option::is_none") )]
	pub regn_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegnCtry", skip_serializing_if = "Option::is_none") )]
	pub regn_ctry: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegnDt", skip_serializing_if = "Option::is_none") )]
	pub regn_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxtnIdNb", skip_serializing_if = "Option::is_none") )]
	pub taxtn_id_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxtnCtry", skip_serializing_if = "Option::is_none") )]
	pub taxtn_ctry: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtryOfOpr", skip_serializing_if = "Option::is_none") )]
	pub ctry_of_opr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BrdRsltnInd", skip_serializing_if = "Option::is_none") )]
	pub brd_rsltn_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizAdr", skip_serializing_if = "Option::is_none") )]
	pub biz_adr: Option<PostalAddress27>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OprlAdr", skip_serializing_if = "Option::is_none") )]
	pub oprl_adr: Option<PostalAddress27>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LglAdr", skip_serializing_if = "Option::is_none") )]
	pub lgl_adr: Option<PostalAddress27>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RprtvOffcr", skip_serializing_if = "Option::is_none") )]
	pub rprtv_offcr: Option<Vec<PartyIdentification272>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrsrMgr", skip_serializing_if = "Option::is_none") )]
	pub trsr_mgr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MainMndtHldr", skip_serializing_if = "Option::is_none") )]
	pub main_mndt_hldr: Option<Vec<PartyIdentification272>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sndr", skip_serializing_if = "Option::is_none") )]
	pub sndr: Option<Vec<PartyIdentification272>>,
}

impl Organisation43 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.full_lgl_nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "full_lgl_nm is shorter than the minimum length of 1".to_string()));
		}
		if self.full_lgl_nm.chars().count() > 350 {
			return Err(ValidationError::new(1002, "full_lgl_nm exceeds the maximum length of 350".to_string()));
		}
		if let Some(ref val) = self.tradg_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tradg_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "tradg_nm exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.org_lgl_sts { val.validate()? }
		if let Some(ref val) = self.regn_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "regn_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "regn_nb exceeds the maximum length of 70".to_string()));
			}
		}
		if let Some(ref val) = self.regn_ctry {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "regn_ctry does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.taxtn_id_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "taxtn_id_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "taxtn_id_nb exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.taxtn_ctry {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "taxtn_ctry does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.ctry_of_opr {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry_of_opr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.biz_adr { val.validate()? }
		if let Some(ref val) = self.oprl_adr { val.validate()? }
		if let Some(ref val) = self.lgl_adr { val.validate()? }
		if let Some(ref vec) = self.rprtv_offcr { for item in vec { item.validate()? } }
		if let Some(ref val) = self.trsr_mgr { val.validate()? }
		if let Some(ref vec) = self.main_mndt_hldr { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.sndr { for item in vec { item.validate()? } }
		Ok(())
	}
}


// Organisation44 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Organisation44 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FullLglNm", skip_serializing_if = "Option::is_none") )]
	pub full_lgl_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgId") )]
	pub org_id: OrganisationIdentification39,
}

impl Organisation44 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.full_lgl_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "full_lgl_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "full_lgl_nm exceeds the maximum length of 350".to_string()));
			}
		}
		self.org_id.validate()?;
		Ok(())
	}
}


// OrganisationIdentification15Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OrganisationIdentification15Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "LEI", skip_serializing_if = "Option::is_none") )]
	pub lei: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<OrganisationIdentification38>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AnyBIC", skip_serializing_if = "Option::is_none") )]
	pub any_bic: Option<String>,
}

impl OrganisationIdentification15Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.lei {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "lei does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.othr { val.validate()? }
		if let Some(ref val) = self.any_bic {
			let pattern = Regex::new("[A-Z0-9]{4,4}[A-Z]{2,2}[A-Z0-9]{2,2}([A-Z0-9]{3,3}){0,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "any_bic does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// OrganisationIdentification28 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OrganisationIdentification28 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstlAdr", skip_serializing_if = "Option::is_none") )]
	pub pstl_adr: Option<PostalAddress6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<OrganisationIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtryOfRes", skip_serializing_if = "Option::is_none") )]
	pub ctry_of_res: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtctDtls") )]
	pub ctct_dtls: ContactDetails2,
}

impl OrganisationIdentification28 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.pstl_adr { val.validate()? }
		if let Some(ref val) = self.id { val.validate()? }
		if let Some(ref val) = self.ctry_of_res {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry_of_res does not match the required pattern".to_string()));
			}
		}
		self.ctct_dtls.validate()?;
		Ok(())
	}
}


// OrganisationIdentification29 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OrganisationIdentification29 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AnyBIC", skip_serializing_if = "Option::is_none") )]
	pub any_bic: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LEI", skip_serializing_if = "Option::is_none") )]
	pub lei: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<Vec<GenericOrganisationIdentification1>>,
}

impl OrganisationIdentification29 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.any_bic {
			let pattern = Regex::new("[A-Z0-9]{4,4}[A-Z]{2,2}[A-Z0-9]{2,2}([A-Z0-9]{3,3}){0,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "any_bic does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.lei {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "lei does not match the required pattern".to_string()));
			}
		}
		if let Some(ref vec) = self.othr { for item in vec { item.validate()? } }
		Ok(())
	}
}


// OrganisationIdentification38 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OrganisationIdentification38 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: GenericIdentification175,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dmcl", skip_serializing_if = "Option::is_none") )]
	pub dmcl: Option<String>,
}

impl OrganisationIdentification38 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.id.validate()?;
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 105 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 105".to_string()));
			}
		}
		if let Some(ref val) = self.dmcl {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "dmcl is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 500 {
				return Err(ValidationError::new(1002, "dmcl exceeds the maximum length of 500".to_string()));
			}
		}
		Ok(())
	}
}


// OrganisationIdentification39 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OrganisationIdentification39 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AnyBIC", skip_serializing_if = "Option::is_none") )]
	pub any_bic: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LEI", skip_serializing_if = "Option::is_none") )]
	pub lei: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<Vec<GenericOrganisationIdentification3>>,
}

impl OrganisationIdentification39 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.any_bic {
			let pattern = Regex::new("[A-Z0-9]{4,4}[A-Z]{2,2}[A-Z0-9]{2,2}([A-Z0-9]{3,3}){0,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "any_bic does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.lei {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "lei does not match the required pattern".to_string()));
			}
		}
		if let Some(ref vec) = self.othr { for item in vec { item.validate()? } }
		Ok(())
	}
}


// OrganisationIdentification40 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OrganisationIdentification40 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AnyBIC", skip_serializing_if = "Option::is_none") )]
	pub any_bic: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LEI", skip_serializing_if = "Option::is_none") )]
	pub lei: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EmailAdr", skip_serializing_if = "Option::is_none") )]
	pub email_adr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<Vec<GenericOrganisationIdentification3>>,
}

impl OrganisationIdentification40 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.any_bic {
			let pattern = Regex::new("[A-Z0-9]{4,4}[A-Z]{2,2}[A-Z0-9]{2,2}([A-Z0-9]{3,3}){0,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "any_bic does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.lei {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "lei does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.email_adr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "email_adr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 256 {
				return Err(ValidationError::new(1002, "email_adr exceeds the maximum length of 256".to_string()));
			}
		}
		if let Some(ref vec) = self.othr { for item in vec { item.validate()? } }
		Ok(())
	}
}


// OrganisationIdentification8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OrganisationIdentification8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AnyBIC", skip_serializing_if = "Option::is_none") )]
	pub any_bic: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<Vec<GenericOrganisationIdentification1>>,
}

impl OrganisationIdentification8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.any_bic {
			let pattern = Regex::new("[A-Z]{6,6}[A-Z2-9][A-NP-Z0-9]([A-Z0-9]{3,3}){0,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "any_bic does not match the required pattern".to_string()));
			}
		}
		if let Some(ref vec) = self.othr { for item in vec { item.validate()? } }
		Ok(())
	}
}


// OrganisationIdentificationSchemeName1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OrganisationIdentificationSchemeName1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl OrganisationIdentificationSchemeName1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// OrganisationLegalStatus1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum OrganisationLegalStatus1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CIOC") )]
	CodeCIOC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CHAR") )]
	CodeCHAR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CICC") )]
	CodeCICC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GENP") )]
	CodeGENP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IAPS") )]
	CodeIAPS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LLPP") )]
	CodeLLPP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PCLG") )]
	CodePCLG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LIMP") )]
	CodeLIMP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PCLS") )]
	CodePCLS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PCLC") )]
	CodePCLC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SOLE") )]
	CodeSOLE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UNLC") )]
	CodeUNLC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UNLT") )]
	CodeUNLT,
}

impl OrganisationLegalStatus1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// OrganisationModification3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OrganisationModification3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FullLglNm") )]
	pub full_lgl_nm: FullLegalNameModification1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgNm", skip_serializing_if = "Option::is_none") )]
	pub tradg_nm: Option<TradingNameModification1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtryOfOpr") )]
	pub ctry_of_opr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegnDt", skip_serializing_if = "Option::is_none") )]
	pub regn_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OprlAdr", skip_serializing_if = "Option::is_none") )]
	pub oprl_adr: Option<AddressModification3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizAdr", skip_serializing_if = "Option::is_none") )]
	pub biz_adr: Option<AddressModification3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LglAdr") )]
	pub lgl_adr: AddressModification3,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BllgAdr", skip_serializing_if = "Option::is_none") )]
	pub bllg_adr: Option<AddressModification3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgId") )]
	pub org_id: OrganisationIdentification39,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RprtvOffcr", skip_serializing_if = "Option::is_none") )]
	pub rprtv_offcr: Option<Vec<PartyModification3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrsrMgr", skip_serializing_if = "Option::is_none") )]
	pub trsr_mgr: Option<PartyModification3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MainMndtHldr", skip_serializing_if = "Option::is_none") )]
	pub main_mndt_hldr: Option<Vec<PartyModification3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sndr", skip_serializing_if = "Option::is_none") )]
	pub sndr: Option<Vec<PartyModification3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LglRprtv", skip_serializing_if = "Option::is_none") )]
	pub lgl_rprtv: Option<Vec<PartyModification3>>,
}

impl OrganisationModification3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.full_lgl_nm.validate()?;
		if let Some(ref val) = self.tradg_nm { val.validate()? }
		let pattern = Regex::new("[A-Z]{2,2}").unwrap();
		if !pattern.is_match(&self.ctry_of_opr) {
			return Err(ValidationError::new(1005, "ctry_of_opr does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.oprl_adr { val.validate()? }
		if let Some(ref val) = self.biz_adr { val.validate()? }
		self.lgl_adr.validate()?;
		if let Some(ref val) = self.bllg_adr { val.validate()? }
		self.org_id.validate()?;
		if let Some(ref vec) = self.rprtv_offcr { for item in vec { item.validate()? } }
		if let Some(ref val) = self.trsr_mgr { val.validate()? }
		if let Some(ref vec) = self.main_mndt_hldr { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.sndr { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.lgl_rprtv { for item in vec { item.validate()? } }
		Ok(())
	}
}


// OrganisationType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OrganisationType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<OrganisationType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl OrganisationType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// OrganisationType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum OrganisationType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "IFUN") )]
	CodeIFUN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRIV") )]
	CodePRIV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PUBL") )]
	CodePUBL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PFUN") )]
	CodePFUN,
}

impl OrganisationType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// OrganisationType2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OrganisationType2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AnyBIC", skip_serializing_if = "Option::is_none") )]
	pub any_bic: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LEI", skip_serializing_if = "Option::is_none") )]
	pub lei: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EmailAdr", skip_serializing_if = "Option::is_none") )]
	pub email_adr: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<Vec<GenericOrganisationType1>>,
}

impl OrganisationType2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.othr { for item in vec { item.validate()? } }
		Ok(())
	}
}


// OriginalActivation3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OriginalActivation3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlDbtrId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_dbtr_id: Option<Party53Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlActvtnData", skip_serializing_if = "Option::is_none") )]
	pub orgnl_actvtn_data: Option<DebtorActivation5>,
}

impl OriginalActivation3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgnl_dbtr_id { val.validate()? }
		if let Some(ref val) = self.orgnl_actvtn_data { val.validate()? }
		Ok(())
	}
}


// OriginalAndCurrentQuantities1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OriginalAndCurrentQuantities1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FaceAmt") )]
	pub face_amt: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AmtsdVal") )]
	pub amtsd_val: f64,
}

impl OriginalAndCurrentQuantities1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// OriginalBusinessInstruction1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OriginalBusinessInstruction1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgNmId", skip_serializing_if = "Option::is_none") )]
	pub msg_nm_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm", skip_serializing_if = "Option::is_none") )]
	pub cre_dt_tm: Option<String>,
}

impl OriginalBusinessInstruction1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.msg_nm_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "msg_nm_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "msg_nm_id exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// OriginalBusinessQuery1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OriginalBusinessQuery1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgNmId", skip_serializing_if = "Option::is_none") )]
	pub msg_nm_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm", skip_serializing_if = "Option::is_none") )]
	pub cre_dt_tm: Option<String>,
}

impl OriginalBusinessQuery1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.msg_nm_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "msg_nm_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "msg_nm_id exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// OriginalEnrolment3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OriginalEnrolment3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlCdtrId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_cdtr_id: Option<Party53Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlEnrlmntData", skip_serializing_if = "Option::is_none") )]
	pub orgnl_enrlmnt_data: Option<CreditorEnrolment5>,
}

impl OriginalEnrolment3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgnl_cdtr_id { val.validate()? }
		if let Some(ref val) = self.orgnl_enrlmnt_data { val.validate()? }
		Ok(())
	}
}


// OriginalGroupHeader17 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OriginalGroupHeader17 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMsgId") )]
	pub orgnl_msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMsgNmId") )]
	pub orgnl_msg_nm_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlCreDtTm", skip_serializing_if = "Option::is_none") )]
	pub orgnl_cre_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlNbOfTxs", skip_serializing_if = "Option::is_none") )]
	pub orgnl_nb_of_txs: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlCtrlSum", skip_serializing_if = "Option::is_none") )]
	pub orgnl_ctrl_sum: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GrpSts", skip_serializing_if = "Option::is_none") )]
	pub grp_sts: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsRsnInf", skip_serializing_if = "Option::is_none") )]
	pub sts_rsn_inf: Option<Vec<StatusReasonInformation12>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfTxsPerSts", skip_serializing_if = "Option::is_none") )]
	pub nb_of_txs_per_sts: Option<Vec<NumberOfTransactionsPerStatus5>>,
}

impl OriginalGroupHeader17 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.orgnl_msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "orgnl_msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.orgnl_msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "orgnl_msg_id exceeds the maximum length of 35".to_string()));
		}
		if self.orgnl_msg_nm_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "orgnl_msg_nm_id is shorter than the minimum length of 1".to_string()));
		}
		if self.orgnl_msg_nm_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "orgnl_msg_nm_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.orgnl_nb_of_txs {
			let pattern = Regex::new("[0-9]{1,15}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "orgnl_nb_of_txs does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.grp_sts {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "grp_sts is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "grp_sts exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref vec) = self.sts_rsn_inf { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.nb_of_txs_per_sts { for item in vec { item.validate()? } }
		Ok(())
	}
}


// OriginalGroupHeader19 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OriginalGroupHeader19 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMsgId") )]
	pub orgnl_msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMsgNmId") )]
	pub orgnl_msg_nm_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlCreDtTm", skip_serializing_if = "Option::is_none") )]
	pub orgnl_cre_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RtrRsnInf", skip_serializing_if = "Option::is_none") )]
	pub rtr_rsn_inf: Option<Vec<PaymentReturnReason7>>,
}

impl OriginalGroupHeader19 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.orgnl_msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "orgnl_msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.orgnl_msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "orgnl_msg_id exceeds the maximum length of 35".to_string()));
		}
		if self.orgnl_msg_nm_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "orgnl_msg_nm_id is shorter than the minimum length of 1".to_string()));
		}
		if self.orgnl_msg_nm_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "orgnl_msg_nm_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref vec) = self.rtr_rsn_inf { for item in vec { item.validate()? } }
		Ok(())
	}
}


// OriginalGroupHeader20 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OriginalGroupHeader20 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMsgId") )]
	pub orgnl_msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMsgNmId") )]
	pub orgnl_msg_nm_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlCreDtTm", skip_serializing_if = "Option::is_none") )]
	pub orgnl_cre_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RvslRsnInf", skip_serializing_if = "Option::is_none") )]
	pub rvsl_rsn_inf: Option<Vec<PaymentReversalReason10>>,
}

impl OriginalGroupHeader20 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.orgnl_msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "orgnl_msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.orgnl_msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "orgnl_msg_id exceeds the maximum length of 35".to_string()));
		}
		if self.orgnl_msg_nm_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "orgnl_msg_nm_id is shorter than the minimum length of 1".to_string()));
		}
		if self.orgnl_msg_nm_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "orgnl_msg_nm_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref vec) = self.rvsl_rsn_inf { for item in vec { item.validate()? } }
		Ok(())
	}
}


// OriginalGroupHeader21 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OriginalGroupHeader21 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "GrpCxlId", skip_serializing_if = "Option::is_none") )]
	pub grp_cxl_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Case", skip_serializing_if = "Option::is_none") )]
	pub case: Option<Case6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMsgId") )]
	pub orgnl_msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMsgNmId") )]
	pub orgnl_msg_nm_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlCreDtTm", skip_serializing_if = "Option::is_none") )]
	pub orgnl_cre_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfTxs", skip_serializing_if = "Option::is_none") )]
	pub nb_of_txs: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrlSum", skip_serializing_if = "Option::is_none") )]
	pub ctrl_sum: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GrpCxl", skip_serializing_if = "Option::is_none") )]
	pub grp_cxl: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CxlRsnInf", skip_serializing_if = "Option::is_none") )]
	pub cxl_rsn_inf: Option<Vec<PaymentCancellationReason6>>,
}

impl OriginalGroupHeader21 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.grp_cxl_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "grp_cxl_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "grp_cxl_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.case { val.validate()? }
		if self.orgnl_msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "orgnl_msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.orgnl_msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "orgnl_msg_id exceeds the maximum length of 35".to_string()));
		}
		if self.orgnl_msg_nm_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "orgnl_msg_nm_id is shorter than the minimum length of 1".to_string()));
		}
		if self.orgnl_msg_nm_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "orgnl_msg_nm_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.nb_of_txs {
			let pattern = Regex::new("[0-9]{1,15}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "nb_of_txs does not match the required pattern".to_string()));
			}
		}
		if let Some(ref vec) = self.cxl_rsn_inf { for item in vec { item.validate()? } }
		Ok(())
	}
}


// OriginalGroupHeader22 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OriginalGroupHeader22 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMsgId") )]
	pub orgnl_msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMsgNmId") )]
	pub orgnl_msg_nm_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlCreDtTm", skip_serializing_if = "Option::is_none") )]
	pub orgnl_cre_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlNbOfTxs", skip_serializing_if = "Option::is_none") )]
	pub orgnl_nb_of_txs: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlCtrlSum", skip_serializing_if = "Option::is_none") )]
	pub orgnl_ctrl_sum: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GrpSts", skip_serializing_if = "Option::is_none") )]
	pub grp_sts: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsRsnInf", skip_serializing_if = "Option::is_none") )]
	pub sts_rsn_inf: Option<Vec<StatusReasonInformation14>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfTxsPerSts", skip_serializing_if = "Option::is_none") )]
	pub nb_of_txs_per_sts: Option<Vec<NumberOfTransactionsPerStatus5>>,
}

impl OriginalGroupHeader22 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.orgnl_msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "orgnl_msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.orgnl_msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "orgnl_msg_id exceeds the maximum length of 35".to_string()));
		}
		if self.orgnl_msg_nm_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "orgnl_msg_nm_id is shorter than the minimum length of 1".to_string()));
		}
		if self.orgnl_msg_nm_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "orgnl_msg_nm_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.orgnl_nb_of_txs {
			let pattern = Regex::new("[0-9]{1,15}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "orgnl_nb_of_txs does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.grp_sts {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "grp_sts is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "grp_sts exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref vec) = self.sts_rsn_inf { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.nb_of_txs_per_sts { for item in vec { item.validate()? } }
		Ok(())
	}
}


// OriginalGroupHeader23 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OriginalGroupHeader23 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlGrpCxlId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_grp_cxl_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RslvdCase", skip_serializing_if = "Option::is_none") )]
	pub rslvd_case: Option<Case6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMsgId") )]
	pub orgnl_msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMsgNmId") )]
	pub orgnl_msg_nm_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlCreDtTm", skip_serializing_if = "Option::is_none") )]
	pub orgnl_cre_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlNbOfTxs", skip_serializing_if = "Option::is_none") )]
	pub orgnl_nb_of_txs: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlCtrlSum", skip_serializing_if = "Option::is_none") )]
	pub orgnl_ctrl_sum: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GrpCxlSts", skip_serializing_if = "Option::is_none") )]
	pub grp_cxl_sts: Option<GroupCancellationStatus1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CxlStsRsnInf", skip_serializing_if = "Option::is_none") )]
	pub cxl_sts_rsn_inf: Option<Vec<CancellationStatusReason5>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfTxsPerCxlSts", skip_serializing_if = "Option::is_none") )]
	pub nb_of_txs_per_cxl_sts: Option<Vec<NumberOfTransactionsPerStatus1>>,
}

impl OriginalGroupHeader23 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgnl_grp_cxl_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_grp_cxl_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_grp_cxl_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.rslvd_case { val.validate()? }
		if self.orgnl_msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "orgnl_msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.orgnl_msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "orgnl_msg_id exceeds the maximum length of 35".to_string()));
		}
		if self.orgnl_msg_nm_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "orgnl_msg_nm_id is shorter than the minimum length of 1".to_string()));
		}
		if self.orgnl_msg_nm_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "orgnl_msg_nm_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.orgnl_nb_of_txs {
			let pattern = Regex::new("[0-9]{1,15}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "orgnl_nb_of_txs does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.grp_cxl_sts { val.validate()? }
		if let Some(ref vec) = self.cxl_sts_rsn_inf { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.nb_of_txs_per_cxl_sts { for item in vec { item.validate()? } }
		Ok(())
	}
}


// OriginalGroupInformation27 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OriginalGroupInformation27 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMsgId") )]
	pub orgnl_msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMsgNmId") )]
	pub orgnl_msg_nm_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlCreDtTm", skip_serializing_if = "Option::is_none") )]
	pub orgnl_cre_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlNbOfTxs", skip_serializing_if = "Option::is_none") )]
	pub orgnl_nb_of_txs: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlCtrlSum", skip_serializing_if = "Option::is_none") )]
	pub orgnl_ctrl_sum: Option<f64>,
}

impl OriginalGroupInformation27 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.orgnl_msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "orgnl_msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.orgnl_msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "orgnl_msg_id exceeds the maximum length of 35".to_string()));
		}
		if self.orgnl_msg_nm_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "orgnl_msg_nm_id is shorter than the minimum length of 1".to_string()));
		}
		if self.orgnl_msg_nm_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "orgnl_msg_nm_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.orgnl_nb_of_txs {
			let pattern = Regex::new("[0-9]{1,15}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "orgnl_nb_of_txs does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// OriginalGroupInformation29 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OriginalGroupInformation29 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMsgId") )]
	pub orgnl_msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMsgNmId") )]
	pub orgnl_msg_nm_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlCreDtTm", skip_serializing_if = "Option::is_none") )]
	pub orgnl_cre_dt_tm: Option<String>,
}

impl OriginalGroupInformation29 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.orgnl_msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "orgnl_msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.orgnl_msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "orgnl_msg_id exceeds the maximum length of 35".to_string()));
		}
		if self.orgnl_msg_nm_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "orgnl_msg_nm_id is shorter than the minimum length of 1".to_string()));
		}
		if self.orgnl_msg_nm_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "orgnl_msg_nm_id exceeds the maximum length of 35".to_string()));
		}
		Ok(())
	}
}


// OriginalGroupInformation32 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OriginalGroupInformation32 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMsgId") )]
	pub orgnl_msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMsgNmId") )]
	pub orgnl_msg_nm_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlCreDtTm", skip_serializing_if = "Option::is_none") )]
	pub orgnl_cre_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlNbOfTxs", skip_serializing_if = "Option::is_none") )]
	pub orgnl_nb_of_txs: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlCtrlSum", skip_serializing_if = "Option::is_none") )]
	pub orgnl_ctrl_sum: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GrpSts", skip_serializing_if = "Option::is_none") )]
	pub grp_sts: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsRsnInf", skip_serializing_if = "Option::is_none") )]
	pub sts_rsn_inf: Option<Vec<StatusReasonInformation14>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfTxsPerSts", skip_serializing_if = "Option::is_none") )]
	pub nb_of_txs_per_sts: Option<Vec<NumberOfTransactionsPerStatus5>>,
}

impl OriginalGroupInformation32 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.orgnl_msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "orgnl_msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.orgnl_msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "orgnl_msg_id exceeds the maximum length of 35".to_string()));
		}
		if self.orgnl_msg_nm_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "orgnl_msg_nm_id is shorter than the minimum length of 1".to_string()));
		}
		if self.orgnl_msg_nm_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "orgnl_msg_nm_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.orgnl_nb_of_txs {
			let pattern = Regex::new("[0-9]{1,15}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "orgnl_nb_of_txs does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.grp_sts {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "grp_sts is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "grp_sts exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref vec) = self.sts_rsn_inf { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.nb_of_txs_per_sts { for item in vec { item.validate()? } }
		Ok(())
	}
}


// OriginalItem8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OriginalItem8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlItmId") )]
	pub orgnl_itm_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlEndToEndId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_end_to_end_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UETR", skip_serializing_if = "Option::is_none") )]
	pub uetr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveOrHistoricCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XpctdValDt", skip_serializing_if = "Option::is_none") )]
	pub xpctd_val_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlItmRef", skip_serializing_if = "Option::is_none") )]
	pub orgnl_itm_ref: Option<OriginalItemReference7>,
}

impl OriginalItem8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.orgnl_itm_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "orgnl_itm_id is shorter than the minimum length of 1".to_string()));
		}
		if self.orgnl_itm_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "orgnl_itm_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.orgnl_end_to_end_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_end_to_end_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_end_to_end_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.uetr {
			let pattern = Regex::new("[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "uetr does not match the required pattern".to_string()));
			}
		}
		self.amt.validate()?;
		if let Some(ref val) = self.orgnl_itm_ref { val.validate()? }
		Ok(())
	}
}


// OriginalItemAndStatus8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OriginalItemAndStatus8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlItmId") )]
	pub orgnl_itm_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlEndToEndId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_end_to_end_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlUETR", skip_serializing_if = "Option::is_none") )]
	pub orgnl_uetr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveOrHistoricCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XpctdValDt", skip_serializing_if = "Option::is_none") )]
	pub xpctd_val_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ItmSts") )]
	pub itm_sts: NotificationStatus3Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlStsInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_sts_inf: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlItmRef", skip_serializing_if = "Option::is_none") )]
	pub orgnl_itm_ref: Option<OriginalItemReference7>,
}

impl OriginalItemAndStatus8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.orgnl_itm_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "orgnl_itm_id is shorter than the minimum length of 1".to_string()));
		}
		if self.orgnl_itm_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "orgnl_itm_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.orgnl_end_to_end_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_end_to_end_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_end_to_end_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_uetr {
			let pattern = Regex::new("[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "orgnl_uetr does not match the required pattern".to_string()));
			}
		}
		self.amt.validate()?;
		self.itm_sts.validate()?;
		if let Some(ref val) = self.addtl_sts_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_sts_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 105 {
				return Err(ValidationError::new(1002, "addtl_sts_inf exceeds the maximum length of 105".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_itm_ref { val.validate()? }
		Ok(())
	}
}


// OriginalItemReference7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OriginalItemReference7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Acct", skip_serializing_if = "Option::is_none") )]
	pub acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctOwnr", skip_serializing_if = "Option::is_none") )]
	pub acct_ownr: Option<Party50Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcr", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdAcct", skip_serializing_if = "Option::is_none") )]
	pub rltd_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dbtr", skip_serializing_if = "Option::is_none") )]
	pub dbtr: Option<Party50Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgt", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Purp", skip_serializing_if = "Option::is_none") )]
	pub purp: Option<Purpose2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdRmtInf", skip_serializing_if = "Option::is_none") )]
	pub rltd_rmt_inf: Option<RemittanceLocation8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RmtInf", skip_serializing_if = "Option::is_none") )]
	pub rmt_inf: Option<RemittanceInformation22>,
}

impl OriginalItemReference7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.acct { val.validate()? }
		if let Some(ref val) = self.acct_ownr { val.validate()? }
		if let Some(ref val) = self.acct_svcr { val.validate()? }
		if let Some(ref val) = self.rltd_acct { val.validate()? }
		if let Some(ref val) = self.dbtr { val.validate()? }
		if let Some(ref val) = self.dbtr_agt { val.validate()? }
		if let Some(ref val) = self.intrmy_agt { val.validate()? }
		if let Some(ref val) = self.purp { val.validate()? }
		if let Some(ref val) = self.rltd_rmt_inf { val.validate()? }
		if let Some(ref val) = self.rmt_inf { val.validate()? }
		Ok(())
	}
}


// OriginalMandate10Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OriginalMandate10Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMndtId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_mndt_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMndt", skip_serializing_if = "Option::is_none") )]
	pub orgnl_mndt: Option<Mandate20>,
}

impl OriginalMandate10Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgnl_mndt_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_mndt_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_mndt_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_mndt { val.validate()? }
		Ok(())
	}
}


// OriginalMandate11Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OriginalMandate11Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMndtId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_mndt_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMndt", skip_serializing_if = "Option::is_none") )]
	pub orgnl_mndt: Option<Mandate22>,
}

impl OriginalMandate11Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgnl_mndt_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_mndt_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_mndt_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_mndt { val.validate()? }
		Ok(())
	}
}


// OriginalMessage6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OriginalMessage6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlSndr", skip_serializing_if = "Option::is_none") )]
	pub orgnl_sndr: Option<Party50Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMsgId") )]
	pub orgnl_msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMsgNmId") )]
	pub orgnl_msg_nm_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlCreDtTm", skip_serializing_if = "Option::is_none") )]
	pub orgnl_cre_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlPackgId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_packg_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlRcrdId") )]
	pub orgnl_rcrd_id: String,
}

impl OriginalMessage6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgnl_sndr { val.validate()? }
		if self.orgnl_msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "orgnl_msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.orgnl_msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "orgnl_msg_id exceeds the maximum length of 35".to_string()));
		}
		if self.orgnl_msg_nm_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "orgnl_msg_nm_id is shorter than the minimum length of 1".to_string()));
		}
		if self.orgnl_msg_nm_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "orgnl_msg_nm_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.orgnl_packg_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_packg_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_packg_id exceeds the maximum length of 35".to_string()));
			}
		}
		if self.orgnl_rcrd_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "orgnl_rcrd_id is shorter than the minimum length of 1".to_string()));
		}
		if self.orgnl_rcrd_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "orgnl_rcrd_id exceeds the maximum length of 35".to_string()));
		}
		Ok(())
	}
}


// OriginalMessage7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OriginalMessage7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlSndr", skip_serializing_if = "Option::is_none") )]
	pub orgnl_sndr: Option<Party50Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMsgId") )]
	pub orgnl_msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMsgNmId") )]
	pub orgnl_msg_nm_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlCreDtTm", skip_serializing_if = "Option::is_none") )]
	pub orgnl_cre_dt_tm: Option<String>,
}

impl OriginalMessage7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgnl_sndr { val.validate()? }
		if self.orgnl_msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "orgnl_msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.orgnl_msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "orgnl_msg_id exceeds the maximum length of 35".to_string()));
		}
		if self.orgnl_msg_nm_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "orgnl_msg_nm_id is shorter than the minimum length of 1".to_string()));
		}
		if self.orgnl_msg_nm_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "orgnl_msg_nm_id exceeds the maximum length of 35".to_string()));
		}
		Ok(())
	}
}


// OriginalMessageAndIssuer1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OriginalMessageAndIssuer1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgNmId", skip_serializing_if = "Option::is_none") )]
	pub msg_nm_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgtrNm", skip_serializing_if = "Option::is_none") )]
	pub orgtr_nm: Option<String>,
}

impl OriginalMessageAndIssuer1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.msg_nm_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "msg_nm_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "msg_nm_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgtr_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgtr_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "orgtr_nm exceeds the maximum length of 70".to_string()));
			}
		}
		Ok(())
	}
}


// OriginalMessageInformation1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OriginalMessageInformation1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgNmId") )]
	pub msg_nm_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm", skip_serializing_if = "Option::is_none") )]
	pub cre_dt_tm: Option<String>,
}

impl OriginalMessageInformation1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		if self.msg_nm_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_nm_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_nm_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_nm_id exceeds the maximum length of 35".to_string()));
		}
		Ok(())
	}
}


// OriginalNotification15 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OriginalNotification15 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMsgId") )]
	pub orgnl_msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlCreDtTm", skip_serializing_if = "Option::is_none") )]
	pub orgnl_cre_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlNtfctnId") )]
	pub orgnl_ntfctn_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtfctnSts", skip_serializing_if = "Option::is_none") )]
	pub ntfctn_sts: Option<NotificationStatus3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlStsInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_sts_inf: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlNtfctnRef", skip_serializing_if = "Option::is_none") )]
	pub orgnl_ntfctn_ref: Option<Vec<OriginalNotificationReference13>>,
}

impl OriginalNotification15 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.orgnl_msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "orgnl_msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.orgnl_msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "orgnl_msg_id exceeds the maximum length of 35".to_string()));
		}
		if self.orgnl_ntfctn_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "orgnl_ntfctn_id is shorter than the minimum length of 1".to_string()));
		}
		if self.orgnl_ntfctn_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "orgnl_ntfctn_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.ntfctn_sts { val.validate()? }
		if let Some(ref val) = self.addtl_sts_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_sts_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "addtl_sts_inf exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref vec) = self.orgnl_ntfctn_ref { for item in vec { item.validate()? } }
		Ok(())
	}
}


// OriginalNotification16 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OriginalNotification16 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMsgId") )]
	pub orgnl_msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlCreDtTm", skip_serializing_if = "Option::is_none") )]
	pub orgnl_cre_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlNtfctnId") )]
	pub orgnl_ntfctn_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtfctnCxl", skip_serializing_if = "Option::is_none") )]
	pub ntfctn_cxl: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlNtfctnRef", skip_serializing_if = "Option::is_none") )]
	pub orgnl_ntfctn_ref: Option<Vec<OriginalNotificationReference14>>,
}

impl OriginalNotification16 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.orgnl_msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "orgnl_msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.orgnl_msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "orgnl_msg_id exceeds the maximum length of 35".to_string()));
		}
		if self.orgnl_ntfctn_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "orgnl_ntfctn_id is shorter than the minimum length of 1".to_string()));
		}
		if self.orgnl_ntfctn_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "orgnl_ntfctn_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref vec) = self.orgnl_ntfctn_ref { for item in vec { item.validate()? } }
		Ok(())
	}
}


// OriginalNotificationReference13 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OriginalNotificationReference13 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Acct", skip_serializing_if = "Option::is_none") )]
	pub acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctOwnr", skip_serializing_if = "Option::is_none") )]
	pub acct_ownr: Option<Party50Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcr", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdAcct", skip_serializing_if = "Option::is_none") )]
	pub rltd_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlAmt", skip_serializing_if = "Option::is_none") )]
	pub ttl_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XpctdValDt", skip_serializing_if = "Option::is_none") )]
	pub xpctd_val_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dbtr", skip_serializing_if = "Option::is_none") )]
	pub dbtr: Option<Party50Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgt", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlItmAndSts") )]
	pub orgnl_itm_and_sts: Vec<OriginalItemAndStatus8>,
}

impl OriginalNotificationReference13 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.acct { val.validate()? }
		if let Some(ref val) = self.acct_ownr { val.validate()? }
		if let Some(ref val) = self.acct_svcr { val.validate()? }
		if let Some(ref val) = self.rltd_acct { val.validate()? }
		if let Some(ref val) = self.ttl_amt { val.validate()? }
		if let Some(ref val) = self.dbtr { val.validate()? }
		if let Some(ref val) = self.dbtr_agt { val.validate()? }
		if let Some(ref val) = self.intrmy_agt { val.validate()? }
		for item in &self.orgnl_itm_and_sts { item.validate()? }
		Ok(())
	}
}


// OriginalNotificationReference14 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OriginalNotificationReference14 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Acct", skip_serializing_if = "Option::is_none") )]
	pub acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctOwnr", skip_serializing_if = "Option::is_none") )]
	pub acct_ownr: Option<Party50Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcr", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdAcct", skip_serializing_if = "Option::is_none") )]
	pub rltd_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlAmt", skip_serializing_if = "Option::is_none") )]
	pub ttl_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XpctdValDt", skip_serializing_if = "Option::is_none") )]
	pub xpctd_val_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dbtr", skip_serializing_if = "Option::is_none") )]
	pub dbtr: Option<Party50Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgt", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlItm") )]
	pub orgnl_itm: Vec<OriginalItem8>,
}

impl OriginalNotificationReference14 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.acct { val.validate()? }
		if let Some(ref val) = self.acct_ownr { val.validate()? }
		if let Some(ref val) = self.acct_svcr { val.validate()? }
		if let Some(ref val) = self.rltd_acct { val.validate()? }
		if let Some(ref val) = self.ttl_amt { val.validate()? }
		if let Some(ref val) = self.dbtr { val.validate()? }
		if let Some(ref val) = self.dbtr_agt { val.validate()? }
		if let Some(ref val) = self.intrmy_agt { val.validate()? }
		for item in &self.orgnl_itm { item.validate()? }
		Ok(())
	}
}


// OriginalPaymentInformation10 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OriginalPaymentInformation10 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Refs") )]
	pub refs: TransactionReferences8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtTpInf", skip_serializing_if = "Option::is_none") )]
	pub pmt_tp_inf: Option<PaymentTypeInformation26>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<AmountType3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XchgRateInf", skip_serializing_if = "Option::is_none") )]
	pub xchg_rate_inf: Option<ExchangeRate1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdExctnDt", skip_serializing_if = "Option::is_none") )]
	pub reqd_exctn_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdColltnDt", skip_serializing_if = "Option::is_none") )]
	pub reqd_colltn_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dbtr", skip_serializing_if = "Option::is_none") )]
	pub dbtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgt", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cdtr", skip_serializing_if = "Option::is_none") )]
	pub cdtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAcct", skip_serializing_if = "Option::is_none") )]
	pub cdtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgt", skip_serializing_if = "Option::is_none") )]
	pub cdtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
}

impl OriginalPaymentInformation10 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.refs.validate()?;
		if let Some(ref val) = self.pmt_tp_inf { val.validate()? }
		if let Some(ref val) = self.amt { val.validate()? }
		if let Some(ref val) = self.xchg_rate_inf { val.validate()? }
		if let Some(ref val) = self.reqd_exctn_dt { val.validate()? }
		if let Some(ref val) = self.dbtr { val.validate()? }
		if let Some(ref val) = self.dbtr_acct { val.validate()? }
		if let Some(ref val) = self.dbtr_agt { val.validate()? }
		if let Some(ref val) = self.cdtr { val.validate()? }
		if let Some(ref val) = self.cdtr_acct { val.validate()? }
		if let Some(ref val) = self.cdtr_agt { val.validate()? }
		Ok(())
	}
}


// OriginalPaymentInstruction47 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OriginalPaymentInstruction47 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlPmtInfId") )]
	pub orgnl_pmt_inf_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlNbOfTxs", skip_serializing_if = "Option::is_none") )]
	pub orgnl_nb_of_txs: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlCtrlSum", skip_serializing_if = "Option::is_none") )]
	pub orgnl_ctrl_sum: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtInfSts", skip_serializing_if = "Option::is_none") )]
	pub pmt_inf_sts: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsRsnInf", skip_serializing_if = "Option::is_none") )]
	pub sts_rsn_inf: Option<Vec<StatusReasonInformation14>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfTxsPerSts", skip_serializing_if = "Option::is_none") )]
	pub nb_of_txs_per_sts: Option<Vec<NumberOfTransactionsPerStatus5>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxInfAndSts", skip_serializing_if = "Option::is_none") )]
	pub tx_inf_and_sts: Option<Vec<PaymentTransaction150>>,
}

impl OriginalPaymentInstruction47 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.orgnl_pmt_inf_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "orgnl_pmt_inf_id is shorter than the minimum length of 1".to_string()));
		}
		if self.orgnl_pmt_inf_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "orgnl_pmt_inf_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.orgnl_nb_of_txs {
			let pattern = Regex::new("[0-9]{1,15}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "orgnl_nb_of_txs does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.pmt_inf_sts {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pmt_inf_sts is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "pmt_inf_sts exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref vec) = self.sts_rsn_inf { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.nb_of_txs_per_sts { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.tx_inf_and_sts { for item in vec { item.validate()? } }
		Ok(())
	}
}


// OriginalPaymentInstruction48 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OriginalPaymentInstruction48 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlPmtInfCxlId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_pmt_inf_cxl_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RslvdCase", skip_serializing_if = "Option::is_none") )]
	pub rslvd_case: Option<Case6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlPmtInfId") )]
	pub orgnl_pmt_inf_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlGrpInf", skip_serializing_if = "Option::is_none") )]
	pub orgnl_grp_inf: Option<OriginalGroupInformation29>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlNbOfTxs", skip_serializing_if = "Option::is_none") )]
	pub orgnl_nb_of_txs: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlCtrlSum", skip_serializing_if = "Option::is_none") )]
	pub orgnl_ctrl_sum: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtInfCxlSts", skip_serializing_if = "Option::is_none") )]
	pub pmt_inf_cxl_sts: Option<GroupCancellationStatus1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CxlStsRsnInf", skip_serializing_if = "Option::is_none") )]
	pub cxl_sts_rsn_inf: Option<Vec<CancellationStatusReason5>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfTxsPerCxlSts", skip_serializing_if = "Option::is_none") )]
	pub nb_of_txs_per_cxl_sts: Option<Vec<NumberOfCancellationsPerStatus1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxInfAndSts", skip_serializing_if = "Option::is_none") )]
	pub tx_inf_and_sts: Option<Vec<PaymentTransaction153>>,
}

impl OriginalPaymentInstruction48 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgnl_pmt_inf_cxl_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_pmt_inf_cxl_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_pmt_inf_cxl_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.rslvd_case { val.validate()? }
		if self.orgnl_pmt_inf_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "orgnl_pmt_inf_id is shorter than the minimum length of 1".to_string()));
		}
		if self.orgnl_pmt_inf_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "orgnl_pmt_inf_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.orgnl_grp_inf { val.validate()? }
		if let Some(ref val) = self.orgnl_nb_of_txs {
			let pattern = Regex::new("[0-9]{1,15}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "orgnl_nb_of_txs does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.pmt_inf_cxl_sts { val.validate()? }
		if let Some(ref vec) = self.cxl_sts_rsn_inf { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.nb_of_txs_per_cxl_sts { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.tx_inf_and_sts { for item in vec { item.validate()? } }
		Ok(())
	}
}


// OriginalPaymentInstruction49 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OriginalPaymentInstruction49 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtCxlId", skip_serializing_if = "Option::is_none") )]
	pub pmt_cxl_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Case", skip_serializing_if = "Option::is_none") )]
	pub case: Option<Case6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlPmtInfId") )]
	pub orgnl_pmt_inf_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlGrpInf", skip_serializing_if = "Option::is_none") )]
	pub orgnl_grp_inf: Option<OriginalGroupInformation29>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfTxs", skip_serializing_if = "Option::is_none") )]
	pub nb_of_txs: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrlSum", skip_serializing_if = "Option::is_none") )]
	pub ctrl_sum: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtInfCxl", skip_serializing_if = "Option::is_none") )]
	pub pmt_inf_cxl: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CxlRsnInf", skip_serializing_if = "Option::is_none") )]
	pub cxl_rsn_inf: Option<Vec<PaymentCancellationReason6>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxInf", skip_serializing_if = "Option::is_none") )]
	pub tx_inf: Option<Vec<PaymentTransaction154>>,
}

impl OriginalPaymentInstruction49 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.pmt_cxl_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pmt_cxl_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "pmt_cxl_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.case { val.validate()? }
		if self.orgnl_pmt_inf_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "orgnl_pmt_inf_id is shorter than the minimum length of 1".to_string()));
		}
		if self.orgnl_pmt_inf_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "orgnl_pmt_inf_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.orgnl_grp_inf { val.validate()? }
		if let Some(ref val) = self.nb_of_txs {
			let pattern = Regex::new("[0-9]{1,15}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "nb_of_txs does not match the required pattern".to_string()));
			}
		}
		if let Some(ref vec) = self.cxl_rsn_inf { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.tx_inf { for item in vec { item.validate()? } }
		Ok(())
	}
}


// OriginalPaymentInstruction50 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OriginalPaymentInstruction50 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RvslPmtInfId", skip_serializing_if = "Option::is_none") )]
	pub rvsl_pmt_inf_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlPmtInfId") )]
	pub orgnl_pmt_inf_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlNbOfTxs", skip_serializing_if = "Option::is_none") )]
	pub orgnl_nb_of_txs: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlCtrlSum", skip_serializing_if = "Option::is_none") )]
	pub orgnl_ctrl_sum: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BtchBookg", skip_serializing_if = "Option::is_none") )]
	pub btch_bookg: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtInfRvsl", skip_serializing_if = "Option::is_none") )]
	pub pmt_inf_rvsl: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RvslRsnInf", skip_serializing_if = "Option::is_none") )]
	pub rvsl_rsn_inf: Option<Vec<PaymentReversalReason10>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxInf", skip_serializing_if = "Option::is_none") )]
	pub tx_inf: Option<Vec<PaymentTransaction156>>,
}

impl OriginalPaymentInstruction50 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rvsl_pmt_inf_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rvsl_pmt_inf_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "rvsl_pmt_inf_id exceeds the maximum length of 35".to_string()));
			}
		}
		if self.orgnl_pmt_inf_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "orgnl_pmt_inf_id is shorter than the minimum length of 1".to_string()));
		}
		if self.orgnl_pmt_inf_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "orgnl_pmt_inf_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.orgnl_nb_of_txs {
			let pattern = Regex::new("[0-9]{1,15}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "orgnl_nb_of_txs does not match the required pattern".to_string()));
			}
		}
		if let Some(ref vec) = self.rvsl_rsn_inf { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.tx_inf { for item in vec { item.validate()? } }
		Ok(())
	}
}


// OriginalPaymentInstruction51 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OriginalPaymentInstruction51 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlPmtInfId") )]
	pub orgnl_pmt_inf_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlNbOfTxs", skip_serializing_if = "Option::is_none") )]
	pub orgnl_nb_of_txs: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlCtrlSum", skip_serializing_if = "Option::is_none") )]
	pub orgnl_ctrl_sum: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtInfSts", skip_serializing_if = "Option::is_none") )]
	pub pmt_inf_sts: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsRsnInf", skip_serializing_if = "Option::is_none") )]
	pub sts_rsn_inf: Option<Vec<StatusReasonInformation14>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfTxsPerSts", skip_serializing_if = "Option::is_none") )]
	pub nb_of_txs_per_sts: Option<Vec<NumberOfTransactionsPerStatus5>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxInfAndSts", skip_serializing_if = "Option::is_none") )]
	pub tx_inf_and_sts: Option<Vec<PaymentTransaction160>>,
}

impl OriginalPaymentInstruction51 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.orgnl_pmt_inf_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "orgnl_pmt_inf_id is shorter than the minimum length of 1".to_string()));
		}
		if self.orgnl_pmt_inf_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "orgnl_pmt_inf_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.orgnl_nb_of_txs {
			let pattern = Regex::new("[0-9]{1,15}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "orgnl_nb_of_txs does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.pmt_inf_sts {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pmt_inf_sts is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "pmt_inf_sts exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref vec) = self.sts_rsn_inf { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.nb_of_txs_per_sts { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.tx_inf_and_sts { for item in vec { item.validate()? } }
		Ok(())
	}
}


// OriginalReportStatistics3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OriginalReportStatistics3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNbOfRcrds") )]
	pub ttl_nb_of_rcrds: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfRcrdsPerSts") )]
	pub nb_of_rcrds_per_sts: Vec<NumberOfRecordsPerStatus1>,
}

impl OriginalReportStatistics3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[0-9]{1,15}").unwrap();
		if !pattern.is_match(&self.ttl_nb_of_rcrds) {
			return Err(ValidationError::new(1005, "ttl_nb_of_rcrds does not match the required pattern".to_string()));
		}
		for item in &self.nb_of_rcrds_per_sts { item.validate()? }
		Ok(())
	}
}


// OriginalTransactionReference35 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OriginalTransactionReference35 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBkSttlmAmt", skip_serializing_if = "Option::is_none") )]
	pub intr_bk_sttlm_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<AmountType4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBkSttlmDt", skip_serializing_if = "Option::is_none") )]
	pub intr_bk_sttlm_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdColltnDt", skip_serializing_if = "Option::is_none") )]
	pub reqd_colltn_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdExctnDt", skip_serializing_if = "Option::is_none") )]
	pub reqd_exctn_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrSchmeId", skip_serializing_if = "Option::is_none") )]
	pub cdtr_schme_id: Option<PartyIdentification135>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmInf", skip_serializing_if = "Option::is_none") )]
	pub sttlm_inf: Option<SettlementInstruction11>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtTpInf", skip_serializing_if = "Option::is_none") )]
	pub pmt_tp_inf: Option<PaymentTypeInformation27>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtMtd", skip_serializing_if = "Option::is_none") )]
	pub pmt_mtd: Option<PaymentMethod4Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MndtRltdInf", skip_serializing_if = "Option::is_none") )]
	pub mndt_rltd_inf: Option<MandateRelatedData2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RmtInf", skip_serializing_if = "Option::is_none") )]
	pub rmt_inf: Option<RemittanceInformation21>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtDbtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_dbtr: Option<Party40Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dbtr", skip_serializing_if = "Option::is_none") )]
	pub dbtr: Option<Party40Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgt", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt: Option<BranchAndFinancialInstitutionIdentification6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgt", skip_serializing_if = "Option::is_none") )]
	pub cdtr_agt: Option<BranchAndFinancialInstitutionIdentification6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub cdtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cdtr", skip_serializing_if = "Option::is_none") )]
	pub cdtr: Option<Party40Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAcct", skip_serializing_if = "Option::is_none") )]
	pub cdtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtCdtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_cdtr: Option<Party40Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Purp", skip_serializing_if = "Option::is_none") )]
	pub purp: Option<Purpose2Choice>,
}

impl OriginalTransactionReference35 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.intr_bk_sttlm_amt { val.validate()? }
		if let Some(ref val) = self.amt { val.validate()? }
		if let Some(ref val) = self.reqd_exctn_dt { val.validate()? }
		if let Some(ref val) = self.cdtr_schme_id { val.validate()? }
		if let Some(ref val) = self.sttlm_inf { val.validate()? }
		if let Some(ref val) = self.pmt_tp_inf { val.validate()? }
		if let Some(ref val) = self.pmt_mtd { val.validate()? }
		if let Some(ref val) = self.mndt_rltd_inf { val.validate()? }
		if let Some(ref val) = self.rmt_inf { val.validate()? }
		if let Some(ref val) = self.ultmt_dbtr { val.validate()? }
		if let Some(ref val) = self.dbtr { val.validate()? }
		if let Some(ref val) = self.dbtr_acct { val.validate()? }
		if let Some(ref val) = self.dbtr_agt { val.validate()? }
		if let Some(ref val) = self.dbtr_agt_acct { val.validate()? }
		if let Some(ref val) = self.cdtr_agt { val.validate()? }
		if let Some(ref val) = self.cdtr_agt_acct { val.validate()? }
		if let Some(ref val) = self.cdtr { val.validate()? }
		if let Some(ref val) = self.cdtr_acct { val.validate()? }
		if let Some(ref val) = self.ultmt_cdtr { val.validate()? }
		if let Some(ref val) = self.purp { val.validate()? }
		Ok(())
	}
}


// OriginalTransactionReference40 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OriginalTransactionReference40 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<AmountType4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdExctnDt", skip_serializing_if = "Option::is_none") )]
	pub reqd_exctn_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XpryDt", skip_serializing_if = "Option::is_none") )]
	pub xpry_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtCond", skip_serializing_if = "Option::is_none") )]
	pub pmt_cond: Option<PaymentCondition2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtTpInf", skip_serializing_if = "Option::is_none") )]
	pub pmt_tp_inf: Option<PaymentTypeInformation29>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtMtd", skip_serializing_if = "Option::is_none") )]
	pub pmt_mtd: Option<PaymentMethod4Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MndtRltdInf", skip_serializing_if = "Option::is_none") )]
	pub mndt_rltd_inf: Option<CreditTransferMandateData1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RmtInf", skip_serializing_if = "Option::is_none") )]
	pub rmt_inf: Option<RemittanceInformation22>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NclsdFile", skip_serializing_if = "Option::is_none") )]
	pub nclsd_file: Option<Vec<Document15>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtDbtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_dbtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dbtr", skip_serializing_if = "Option::is_none") )]
	pub dbtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgt", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgt") )]
	pub cdtr_agt: BranchAndFinancialInstitutionIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub cdtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cdtr") )]
	pub cdtr: PartyIdentification272,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAcct", skip_serializing_if = "Option::is_none") )]
	pub cdtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtCdtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_cdtr: Option<PartyIdentification272>,
}

impl OriginalTransactionReference40 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.amt { val.validate()? }
		if let Some(ref val) = self.reqd_exctn_dt { val.validate()? }
		if let Some(ref val) = self.xpry_dt { val.validate()? }
		if let Some(ref val) = self.pmt_cond { val.validate()? }
		if let Some(ref val) = self.pmt_tp_inf { val.validate()? }
		if let Some(ref val) = self.pmt_mtd { val.validate()? }
		if let Some(ref val) = self.mndt_rltd_inf { val.validate()? }
		if let Some(ref val) = self.rmt_inf { val.validate()? }
		if let Some(ref vec) = self.nclsd_file { for item in vec { item.validate()? } }
		if let Some(ref val) = self.ultmt_dbtr { val.validate()? }
		if let Some(ref val) = self.dbtr { val.validate()? }
		if let Some(ref val) = self.dbtr_acct { val.validate()? }
		if let Some(ref val) = self.dbtr_agt { val.validate()? }
		if let Some(ref val) = self.dbtr_agt_acct { val.validate()? }
		self.cdtr_agt.validate()?;
		if let Some(ref val) = self.cdtr_agt_acct { val.validate()? }
		self.cdtr.validate()?;
		if let Some(ref val) = self.cdtr_acct { val.validate()? }
		if let Some(ref val) = self.ultmt_cdtr { val.validate()? }
		Ok(())
	}
}


// OriginalTransactionReference41 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OriginalTransactionReference41 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBkSttlmAmt", skip_serializing_if = "Option::is_none") )]
	pub intr_bk_sttlm_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<AmountType4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBkSttlmDt", skip_serializing_if = "Option::is_none") )]
	pub intr_bk_sttlm_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdColltnDt", skip_serializing_if = "Option::is_none") )]
	pub reqd_colltn_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdExctnDt", skip_serializing_if = "Option::is_none") )]
	pub reqd_exctn_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrSchmeId", skip_serializing_if = "Option::is_none") )]
	pub cdtr_schme_id: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmInf", skip_serializing_if = "Option::is_none") )]
	pub sttlm_inf: Option<SettlementInstruction15>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtTpInf", skip_serializing_if = "Option::is_none") )]
	pub pmt_tp_inf: Option<PaymentTypeInformation27>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtMtd", skip_serializing_if = "Option::is_none") )]
	pub pmt_mtd: Option<PaymentMethod4Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MndtRltdInf", skip_serializing_if = "Option::is_none") )]
	pub mndt_rltd_inf: Option<MandateRelatedData3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RmtInf", skip_serializing_if = "Option::is_none") )]
	pub rmt_inf: Option<RemittanceInformation22>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtDbtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_dbtr: Option<Party50Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dbtr", skip_serializing_if = "Option::is_none") )]
	pub dbtr: Option<Party50Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgt", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgt", skip_serializing_if = "Option::is_none") )]
	pub cdtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub cdtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cdtr", skip_serializing_if = "Option::is_none") )]
	pub cdtr: Option<Party50Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAcct", skip_serializing_if = "Option::is_none") )]
	pub cdtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtCdtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_cdtr: Option<Party50Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Purp", skip_serializing_if = "Option::is_none") )]
	pub purp: Option<Purpose2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UndrlygCstmrCdtTrf", skip_serializing_if = "Option::is_none") )]
	pub undrlyg_cstmr_cdt_trf: Option<CreditTransferTransaction63>,
}

impl OriginalTransactionReference41 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.intr_bk_sttlm_amt { val.validate()? }
		if let Some(ref val) = self.amt { val.validate()? }
		if let Some(ref val) = self.reqd_exctn_dt { val.validate()? }
		if let Some(ref val) = self.cdtr_schme_id { val.validate()? }
		if let Some(ref val) = self.sttlm_inf { val.validate()? }
		if let Some(ref val) = self.pmt_tp_inf { val.validate()? }
		if let Some(ref val) = self.pmt_mtd { val.validate()? }
		if let Some(ref val) = self.mndt_rltd_inf { val.validate()? }
		if let Some(ref val) = self.rmt_inf { val.validate()? }
		if let Some(ref val) = self.ultmt_dbtr { val.validate()? }
		if let Some(ref val) = self.dbtr { val.validate()? }
		if let Some(ref val) = self.dbtr_acct { val.validate()? }
		if let Some(ref val) = self.dbtr_agt { val.validate()? }
		if let Some(ref val) = self.dbtr_agt_acct { val.validate()? }
		if let Some(ref val) = self.cdtr_agt { val.validate()? }
		if let Some(ref val) = self.cdtr_agt_acct { val.validate()? }
		if let Some(ref val) = self.cdtr { val.validate()? }
		if let Some(ref val) = self.cdtr_acct { val.validate()? }
		if let Some(ref val) = self.ultmt_cdtr { val.validate()? }
		if let Some(ref val) = self.purp { val.validate()? }
		if let Some(ref val) = self.undrlyg_cstmr_cdt_trf { val.validate()? }
		Ok(())
	}
}


// OriginalTransactionReference42 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OriginalTransactionReference42 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBkSttlmAmt", skip_serializing_if = "Option::is_none") )]
	pub intr_bk_sttlm_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<AmountType4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBkSttlmDt", skip_serializing_if = "Option::is_none") )]
	pub intr_bk_sttlm_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdColltnDt", skip_serializing_if = "Option::is_none") )]
	pub reqd_colltn_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdExctnDt", skip_serializing_if = "Option::is_none") )]
	pub reqd_exctn_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrSchmeId", skip_serializing_if = "Option::is_none") )]
	pub cdtr_schme_id: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmInf", skip_serializing_if = "Option::is_none") )]
	pub sttlm_inf: Option<SettlementInstruction15>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtTpInf", skip_serializing_if = "Option::is_none") )]
	pub pmt_tp_inf: Option<PaymentTypeInformation27>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtMtd", skip_serializing_if = "Option::is_none") )]
	pub pmt_mtd: Option<PaymentMethod4Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MndtRltdInf", skip_serializing_if = "Option::is_none") )]
	pub mndt_rltd_inf: Option<MandateRelatedData3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RmtInf", skip_serializing_if = "Option::is_none") )]
	pub rmt_inf: Option<RemittanceInformation22>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtDbtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_dbtr: Option<Party50Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dbtr", skip_serializing_if = "Option::is_none") )]
	pub dbtr: Option<Party50Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgt", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgt", skip_serializing_if = "Option::is_none") )]
	pub cdtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub cdtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cdtr", skip_serializing_if = "Option::is_none") )]
	pub cdtr: Option<Party50Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAcct", skip_serializing_if = "Option::is_none") )]
	pub cdtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtCdtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_cdtr: Option<Party50Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Purp", skip_serializing_if = "Option::is_none") )]
	pub purp: Option<Purpose2Choice>,
}

impl OriginalTransactionReference42 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.intr_bk_sttlm_amt { val.validate()? }
		if let Some(ref val) = self.amt { val.validate()? }
		if let Some(ref val) = self.reqd_exctn_dt { val.validate()? }
		if let Some(ref val) = self.cdtr_schme_id { val.validate()? }
		if let Some(ref val) = self.sttlm_inf { val.validate()? }
		if let Some(ref val) = self.pmt_tp_inf { val.validate()? }
		if let Some(ref val) = self.pmt_mtd { val.validate()? }
		if let Some(ref val) = self.mndt_rltd_inf { val.validate()? }
		if let Some(ref val) = self.rmt_inf { val.validate()? }
		if let Some(ref val) = self.ultmt_dbtr { val.validate()? }
		if let Some(ref val) = self.dbtr { val.validate()? }
		if let Some(ref val) = self.dbtr_acct { val.validate()? }
		if let Some(ref val) = self.dbtr_agt { val.validate()? }
		if let Some(ref val) = self.dbtr_agt_acct { val.validate()? }
		if let Some(ref val) = self.cdtr_agt { val.validate()? }
		if let Some(ref val) = self.cdtr_agt_acct { val.validate()? }
		if let Some(ref val) = self.cdtr { val.validate()? }
		if let Some(ref val) = self.cdtr_acct { val.validate()? }
		if let Some(ref val) = self.ultmt_cdtr { val.validate()? }
		if let Some(ref val) = self.purp { val.validate()? }
		Ok(())
	}
}


// OriginalTransactionReference43 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OriginalTransactionReference43 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId", skip_serializing_if = "Option::is_none") )]
	pub msg_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgNmId", skip_serializing_if = "Option::is_none") )]
	pub msg_nm_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm", skip_serializing_if = "Option::is_none") )]
	pub cre_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlTx", skip_serializing_if = "Option::is_none") )]
	pub orgnl_tx: Option<Vec<PaymentIdentification15>>,
}

impl OriginalTransactionReference43 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.msg_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.msg_nm_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "msg_nm_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "msg_nm_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref vec) = self.orgnl_tx { for item in vec { item.validate()? } }
		Ok(())
	}
}


// OtherAccountStatus1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OtherAccountStatus1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts") )]
	pub sts: GenericIdentification36,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<GenericIdentification36>,
}

impl OtherAccountStatus1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.sts.validate()?;
		if let Some(ref val) = self.rsn { val.validate()? }
		Ok(())
	}
}


// OtherC10CommodityDeliverable2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OtherC10CommodityDeliverable2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType11Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType47Code>,
}

impl OtherC10CommodityDeliverable2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// OtherC10CommodityNonDeliverable2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OtherC10CommodityNonDeliverable2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType11Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType48Code>,
}

impl OtherC10CommodityNonDeliverable2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// OtherContact1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OtherContact1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChanlTp") )]
	pub chanl_tp: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<String>,
}

impl OtherContact1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.chanl_tp.chars().count() < 1 {
			return Err(ValidationError::new(1001, "chanl_tp is shorter than the minimum length of 1".to_string()));
		}
		if self.chanl_tp.chars().count() > 4 {
			return Err(ValidationError::new(1002, "chanl_tp exceeds the maximum length of 4".to_string()));
		}
		if let Some(ref val) = self.id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 128 {
				return Err(ValidationError::new(1002, "id exceeds the maximum length of 128".to_string()));
			}
		}
		Ok(())
	}
}


// OtherDistributionStrategy1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OtherDistributionStrategy1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DstrbtnStrtgyTp", skip_serializing_if = "Option::is_none") )]
	pub dstrbtn_strtgy_tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Trgt", skip_serializing_if = "Option::is_none") )]
	pub trgt: Option<DistributionStrategy1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<AdditionalInformation15>,
}

impl OtherDistributionStrategy1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.dstrbtn_strtgy_tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "dstrbtn_strtgy_tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "dstrbtn_strtgy_tp exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.trgt { val.validate()? }
		if let Some(ref val) = self.addtl_inf { val.validate()? }
		Ok(())
	}
}


// OtherIdentification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OtherIdentification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sfx", skip_serializing_if = "Option::is_none") )]
	pub sfx: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: IdentificationSource3Choice,
}

impl OtherIdentification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.sfx {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "sfx is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 16 {
				return Err(ValidationError::new(1002, "sfx exceeds the maximum length of 16".to_string()));
			}
		}
		self.tp.validate()?;
		Ok(())
	}
}


// OtherIdentification1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OtherIdentification1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<PersonIdentificationType5Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl OtherIdentification1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// OtherIdentification3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OtherIdentification3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<PartyIdentificationType7Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl OtherIdentification3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// OtherIdentification4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OtherIdentification4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: IdentificationSource5Choice,
}

impl OtherIdentification4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		self.tp.validate()?;
		Ok(())
	}
}


// OtherInvestment1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OtherInvestment1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Desc") )]
	pub desc: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveCurrencyAndAmount,
}

impl OtherInvestment1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.desc.chars().count() < 1 {
			return Err(ValidationError::new(1001, "desc is shorter than the minimum length of 1".to_string()));
		}
		if self.desc.chars().count() > 140 {
			return Err(ValidationError::new(1002, "desc exceeds the maximum length of 140".to_string()));
		}
		self.amt.validate()?;
		Ok(())
	}
}


// OtherInvestmentNeed1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OtherInvestmentNeed1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClntObjctvsAndNeedsTp", skip_serializing_if = "Option::is_none") )]
	pub clnt_objctvs_and_needs_tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Trgt", skip_serializing_if = "Option::is_none") )]
	pub trgt: Option<TargetMarket1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<AdditionalInformation15>,
}

impl OtherInvestmentNeed1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.clnt_objctvs_and_needs_tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "clnt_objctvs_and_needs_tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "clnt_objctvs_and_needs_tp exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.trgt { val.validate()? }
		if let Some(ref val) = self.addtl_inf { val.validate()? }
		Ok(())
	}
}


// OtherPayment5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OtherPayment5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtAmt", skip_serializing_if = "Option::is_none") )]
	pub pmt_amt: Option<AmountAndDirection106>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtTp", skip_serializing_if = "Option::is_none") )]
	pub pmt_tp: Option<PaymentType5Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtDt", skip_serializing_if = "Option::is_none") )]
	pub pmt_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtPyer", skip_serializing_if = "Option::is_none") )]
	pub pmt_pyer: Option<PartyIdentification236Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtRcvr", skip_serializing_if = "Option::is_none") )]
	pub pmt_rcvr: Option<PartyIdentification236Choice>,
}

impl OtherPayment5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.pmt_amt { val.validate()? }
		if let Some(ref val) = self.pmt_tp { val.validate()? }
		if let Some(ref val) = self.pmt_pyer { val.validate()? }
		if let Some(ref val) = self.pmt_rcvr { val.validate()? }
		Ok(())
	}
}


// OtherPayment6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OtherPayment6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtCcy", skip_serializing_if = "Option::is_none") )]
	pub pmt_ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtTp", skip_serializing_if = "Option::is_none") )]
	pub pmt_tp: Option<PaymentType5Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtDt", skip_serializing_if = "Option::is_none") )]
	pub pmt_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtPyer", skip_serializing_if = "Option::is_none") )]
	pub pmt_pyer: Option<PartyIdentification236Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtRcvr", skip_serializing_if = "Option::is_none") )]
	pub pmt_rcvr: Option<PartyIdentification236Choice>,
}

impl OtherPayment6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.pmt_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "pmt_ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.pmt_tp { val.validate()? }
		if let Some(ref val) = self.pmt_pyer { val.validate()? }
		if let Some(ref val) = self.pmt_rcvr { val.validate()? }
		Ok(())
	}
}


// OtherReviewRelatedToValueAndOrChargesUKType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum OtherReviewRelatedToValueAndOrChargesUKType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "REVA") )]
	CodeREVA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REVO") )]
	CodeREVO,
}

impl OtherReviewRelatedToValueAndOrChargesUKType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// OtherTargetMarket1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OtherTargetMarket1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrgtMktTp") )]
	pub trgt_mkt_tp: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<AdditionalInformation15>,
}

impl OtherTargetMarket1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.trgt_mkt_tp.chars().count() < 1 {
			return Err(ValidationError::new(1001, "trgt_mkt_tp is shorter than the minimum length of 1".to_string()));
		}
		if self.trgt_mkt_tp.chars().count() > 350 {
			return Err(ValidationError::new(1002, "trgt_mkt_tp exceeds the maximum length of 350".to_string()));
		}
		if let Some(ref val) = self.addtl_inf { val.validate()? }
		Ok(())
	}
}


// OtherTargetMarketInvestor1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OtherTargetMarketInvestor1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstrTp", skip_serializing_if = "Option::is_none") )]
	pub invstr_tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Trgt", skip_serializing_if = "Option::is_none") )]
	pub trgt: Option<TargetMarket3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<AdditionalInformation15>,
}

impl OtherTargetMarketInvestor1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.invstr_tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "invstr_tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "invstr_tp exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.trgt { val.validate()? }
		if let Some(ref val) = self.addtl_inf { val.validate()? }
		Ok(())
	}
}


// OtherTargetMarketInvestorKnowledge1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OtherTargetMarketInvestorKnowledge1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstrKnwldgTp", skip_serializing_if = "Option::is_none") )]
	pub invstr_knwldg_tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Trgt", skip_serializing_if = "Option::is_none") )]
	pub trgt: Option<TargetMarket1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<AdditionalInformation15>,
}

impl OtherTargetMarketInvestorKnowledge1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.invstr_knwldg_tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "invstr_knwldg_tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "invstr_knwldg_tp exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.trgt { val.validate()? }
		if let Some(ref val) = self.addtl_inf { val.validate()? }
		Ok(())
	}
}


// OtherTargetMarketLossBearing1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OtherTargetMarketLossBearing1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AbltyToBearLossesTp", skip_serializing_if = "Option::is_none") )]
	pub ablty_to_bear_losses_tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Trgt", skip_serializing_if = "Option::is_none") )]
	pub trgt: Option<TargetMarket1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<AdditionalInformation15>,
}

impl OtherTargetMarketLossBearing1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ablty_to_bear_losses_tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ablty_to_bear_losses_tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "ablty_to_bear_losses_tp exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.trgt { val.validate()? }
		if let Some(ref val) = self.addtl_inf { val.validate()? }
		Ok(())
	}
}


// OtherTargetMarketRiskTolerance1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OtherTargetMarketRiskTolerance1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RskTlrnceTp", skip_serializing_if = "Option::is_none") )]
	pub rsk_tlrnce_tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Trgt", skip_serializing_if = "Option::is_none") )]
	pub trgt: Option<TargetMarket1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<AdditionalInformation15>,
}

impl OtherTargetMarketRiskTolerance1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rsk_tlrnce_tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rsk_tlrnce_tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "rsk_tlrnce_tp exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.trgt { val.validate()? }
		if let Some(ref val) = self.addtl_inf { val.validate()? }
		Ok(())
	}
}


// OutcomeOfCOLLAssessmentOfValueUKType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum OutcomeOfCOLLAssessmentOfValueUKType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "COL1") )]
	CodeCOL1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "COL2") )]
	CodeCOL2,
}

impl OutcomeOfCOLLAssessmentOfValueUKType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// OutcomeOfPRINValueAssessmentOrReviewUKType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum OutcomeOfPRINValueAssessmentOrReviewUKType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRI2") )]
	CodePRI2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRI1") )]
	CodePRI1,
}

impl OutcomeOfPRINValueAssessmentOrReviewUKType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// OvernightIndexSwap4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OvernightIndexSwap4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DataSetActn", skip_serializing_if = "Option::is_none") )]
	pub data_set_actn: Option<ReportPeriodActivity3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tx", skip_serializing_if = "Option::is_none") )]
	pub tx: Option<Vec<OvernightIndexSwapTransaction4>>,
}

impl OvernightIndexSwap4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.data_set_actn { val.validate()? }
		if let Some(ref vec) = self.tx { for item in vec { item.validate()? } }
		Ok(())
	}
}


// OvernightIndexSwapTransaction4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OvernightIndexSwapTransaction4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptdTxSts") )]
	pub rptd_tx_sts: TransactionOperationType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NvtnSts", skip_serializing_if = "Option::is_none") )]
	pub nvtn_sts: Option<NovationStatus1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BrnchId", skip_serializing_if = "Option::is_none") )]
	pub brnch_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnqTxIdr", skip_serializing_if = "Option::is_none") )]
	pub unq_tx_idr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtryTxId") )]
	pub prtry_tx_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdPrtryTxId", skip_serializing_if = "Option::is_none") )]
	pub rltd_prtry_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtyPrtryTxId", skip_serializing_if = "Option::is_none") )]
	pub ctr_pty_prtry_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtyId") )]
	pub ctr_pty_id: CounterpartyIdentification3Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradDt") )]
	pub trad_dt: DateAndDateTimeChoice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StartDt") )]
	pub start_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MtrtyDt") )]
	pub mtrty_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FxdIntrstRate") )]
	pub fxd_intrst_rate: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxTp") )]
	pub tx_tp: OvernightIndexSwapType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxNmnlAmt") )]
	pub tx_nmnl_amt: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl OvernightIndexSwapTransaction4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.rptd_tx_sts.validate()?;
		if let Some(ref val) = self.nvtn_sts { val.validate()? }
		if let Some(ref val) = self.brnch_id {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "brnch_id does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.unq_tx_idr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "unq_tx_idr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 105 {
				return Err(ValidationError::new(1002, "unq_tx_idr exceeds the maximum length of 105".to_string()));
			}
		}
		if self.prtry_tx_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "prtry_tx_id is shorter than the minimum length of 1".to_string()));
		}
		if self.prtry_tx_id.chars().count() > 105 {
			return Err(ValidationError::new(1002, "prtry_tx_id exceeds the maximum length of 105".to_string()));
		}
		if let Some(ref val) = self.rltd_prtry_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rltd_prtry_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 105 {
				return Err(ValidationError::new(1002, "rltd_prtry_tx_id exceeds the maximum length of 105".to_string()));
			}
		}
		if let Some(ref val) = self.ctr_pty_prtry_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ctr_pty_prtry_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 105 {
				return Err(ValidationError::new(1002, "ctr_pty_prtry_tx_id exceeds the maximum length of 105".to_string()));
			}
		}
		self.ctr_pty_id.validate()?;
		self.trad_dt.validate()?;
		self.tx_tp.validate()?;
		self.tx_nmnl_amt.validate()?;
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// OvernightIndexSwapType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum OvernightIndexSwapType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "PAID") )]
	CodePAID,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RECE") )]
	CodeRECE,
}

impl OvernightIndexSwapType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// OwnerIdentification3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OwnerIdentification3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "IndvOwnrId", skip_serializing_if = "Option::is_none") )]
	pub indv_ownr_id: Option<IndividualPersonIdentification2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgOwnrId", skip_serializing_if = "Option::is_none") )]
	pub org_ownr_id: Option<PartyIdentification139>,
}

impl OwnerIdentification3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.indv_ownr_id { val.validate()? }
		if let Some(ref val) = self.org_ownr_id { val.validate()? }
		Ok(())
	}
}


// OwnershipBeneficiaryRate1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OwnershipBeneficiaryRate1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rate", skip_serializing_if = "Option::is_none") )]
	pub rate: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Frctn", skip_serializing_if = "Option::is_none") )]
	pub frctn: Option<String>,
}

impl OwnershipBeneficiaryRate1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.frctn {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "frctn is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "frctn exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// OwnershipType2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct OwnershipType2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<AccountOwnershipType4Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl OwnershipType2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// POIComponentType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum POIComponentType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "SOFT") )]
	CodeSOFT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EMVK") )]
	CodeEMVK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EMVO") )]
	CodeEMVO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MRIT") )]
	CodeMRIT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CHIT") )]
	CodeCHIT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SECM") )]
	CodeSECM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PEDV") )]
	CodePEDV,
}

impl POIComponentType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PTRREvent2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PTRREvent2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tchnq") )]
	pub tchnq: RiskReductionService1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SvcPrvdr", skip_serializing_if = "Option::is_none") )]
	pub svc_prvdr: Option<OrganisationIdentification15Choice>,
}

impl PTRREvent2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tchnq.validate()?;
		if let Some(ref val) = self.svc_prvdr { val.validate()? }
		Ok(())
	}
}


// PTRREvent3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PTRREvent3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tchnq", skip_serializing_if = "Option::is_none") )]
	pub tchnq: Option<RiskReductionService1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SvcPrvdr", skip_serializing_if = "Option::is_none") )]
	pub svc_prvdr: Option<OrganisationIdentification15Choice>,
}

impl PTRREvent3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tchnq { val.validate()? }
		if let Some(ref val) = self.svc_prvdr { val.validate()? }
		Ok(())
	}
}


// Package4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Package4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CmplxTradId", skip_serializing_if = "Option::is_none") )]
	pub cmplx_trad_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FxSwpLkId", skip_serializing_if = "Option::is_none") )]
	pub fx_swp_lk_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pric", skip_serializing_if = "Option::is_none") )]
	pub pric: Option<SecuritiesTransactionPrice17Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sprd", skip_serializing_if = "Option::is_none") )]
	pub sprd: Option<SecuritiesTransactionPrice20Choice>,
}

impl Package4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cmplx_trad_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cmplx_trad_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 100 {
				return Err(ValidationError::new(1002, "cmplx_trad_id exceeds the maximum length of 100".to_string()));
			}
		}
		if let Some(ref val) = self.fx_swp_lk_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "fx_swp_lk_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 100 {
				return Err(ValidationError::new(1002, "fx_swp_lk_id exceeds the maximum length of 100".to_string()));
			}
		}
		if let Some(ref val) = self.pric { val.validate()? }
		if let Some(ref val) = self.sprd { val.validate()? }
		Ok(())
	}
}


// Pagination ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Pagination {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PgNb") )]
	pub pg_nb: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LastPgInd") )]
	pub last_pg_ind: bool,
}

impl Pagination {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[0-9]{1,5}").unwrap();
		if !pattern.is_match(&self.pg_nb) {
			return Err(ValidationError::new(1005, "pg_nb does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// Pagination1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Pagination1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PgNb") )]
	pub pg_nb: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LastPgInd") )]
	pub last_pg_ind: bool,
}

impl Pagination1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[0-9]{1,5}").unwrap();
		if !pattern.is_match(&self.pg_nb) {
			return Err(ValidationError::new(1005, "pg_nb does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// PairedReconciled3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PairedReconciled3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CLRC") )]
	CodeCLRC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LNRC") )]
	CodeLNRC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PARD") )]
	CodePARD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RECO") )]
	CodeRECO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UNPR") )]
	CodeUNPR,
}

impl PairedReconciled3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PairingStatus1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PairingStatus1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "PARD") )]
	CodePARD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UNPR") )]
	CodeUNPR,
}

impl PairingStatus1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PaperCommodityContainerBoard1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaperCommodityContainerBoard1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType8Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType35Code>,
}

impl PaperCommodityContainerBoard1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// PaperCommodityContainerBoard2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaperCommodityContainerBoard2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType8Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType35Code>,
}

impl PaperCommodityContainerBoard2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// PaperCommodityNewsprint1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaperCommodityNewsprint1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType8Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType36Code>,
}

impl PaperCommodityNewsprint1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// PaperCommodityNewsprint2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaperCommodityNewsprint2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType8Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType36Code>,
}

impl PaperCommodityNewsprint2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// PaperCommodityOther1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaperCommodityOther1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType8Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType49Code>,
}

impl PaperCommodityOther1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// PaperCommodityPulp1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaperCommodityPulp1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType8Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType37Code>,
}

impl PaperCommodityPulp1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// PaperCommodityPulp2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaperCommodityPulp2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType8Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType37Code>,
}

impl PaperCommodityPulp2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// PaperCommodityRecoveredPaper1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaperCommodityRecoveredPaper1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType8Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType38Code>,
}

impl PaperCommodityRecoveredPaper1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// PaperCommodityRecoveredPaper2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaperCommodityRecoveredPaper2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType8Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType49Code>,
}

impl PaperCommodityRecoveredPaper2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// PaperCommodityRecoveredPaper3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaperCommodityRecoveredPaper3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType8Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType50Code>,
}

impl PaperCommodityRecoveredPaper3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// ParentCashAccount5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ParentCashAccount5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Lvl", skip_serializing_if = "Option::is_none") )]
	pub lvl: Option<AccountLevel1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: CashAccount40,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Svcr", skip_serializing_if = "Option::is_none") )]
	pub svcr: Option<BranchAndFinancialInstitutionIdentification8>,
}

impl ParentCashAccount5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.lvl { val.validate()? }
		self.id.validate()?;
		if let Some(ref val) = self.svcr { val.validate()? }
		Ok(())
	}
}


// PartialSettlement2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PartialSettlement2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "PAIN") )]
	CodePAIN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PARC") )]
	CodePARC,
}

impl PartialSettlement2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Party11Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Party11Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgId", skip_serializing_if = "Option::is_none") )]
	pub org_id: Option<OrganisationIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvtId", skip_serializing_if = "Option::is_none") )]
	pub prvt_id: Option<PersonIdentification5>,
}

impl Party11Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.org_id { val.validate()? }
		if let Some(ref val) = self.prvt_id { val.validate()? }
		Ok(())
	}
}


// Party38Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Party38Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgId", skip_serializing_if = "Option::is_none") )]
	pub org_id: Option<OrganisationIdentification29>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvtId", skip_serializing_if = "Option::is_none") )]
	pub prvt_id: Option<PersonIdentification13>,
}

impl Party38Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.org_id { val.validate()? }
		if let Some(ref val) = self.prvt_id { val.validate()? }
		Ok(())
	}
}


// Party40Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Party40Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pty", skip_serializing_if = "Option::is_none") )]
	pub pty: Option<PartyIdentification135>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Agt", skip_serializing_if = "Option::is_none") )]
	pub agt: Option<BranchAndFinancialInstitutionIdentification6>,
}

impl Party40Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.pty { val.validate()? }
		if let Some(ref val) = self.agt { val.validate()? }
		Ok(())
	}
}


// Party44Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Party44Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgId", skip_serializing_if = "Option::is_none") )]
	pub org_id: Option<PartyIdentification135>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FIId", skip_serializing_if = "Option::is_none") )]
	pub fi_id: Option<BranchAndFinancialInstitutionIdentification6>,
}

impl Party44Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.org_id { val.validate()? }
		if let Some(ref val) = self.fi_id { val.validate()? }
		Ok(())
	}
}


// Party47Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Party47Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Org", skip_serializing_if = "Option::is_none") )]
	pub org: Option<Organisation39>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IndvPrsn", skip_serializing_if = "Option::is_none") )]
	pub indv_prsn: Option<IndividualPerson37>,
}

impl Party47Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.org { val.validate()? }
		if let Some(ref val) = self.indv_prsn { val.validate()? }
		Ok(())
	}
}


// Party48Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Party48Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Org", skip_serializing_if = "Option::is_none") )]
	pub org: Option<Organisation40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IndvPrsn", skip_serializing_if = "Option::is_none") )]
	pub indv_prsn: Option<IndividualPerson38>,
}

impl Party48Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.org { val.validate()? }
		if let Some(ref val) = self.indv_prsn { val.validate()? }
		Ok(())
	}
}


// Party50Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Party50Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pty", skip_serializing_if = "Option::is_none") )]
	pub pty: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Agt", skip_serializing_if = "Option::is_none") )]
	pub agt: Option<BranchAndFinancialInstitutionIdentification8>,
}

impl Party50Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.pty { val.validate()? }
		if let Some(ref val) = self.agt { val.validate()? }
		Ok(())
	}
}


// Party51Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Party51Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgId", skip_serializing_if = "Option::is_none") )]
	pub org_id: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FIId", skip_serializing_if = "Option::is_none") )]
	pub fi_id: Option<BranchAndFinancialInstitutionIdentification8>,
}

impl Party51Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.org_id { val.validate()? }
		if let Some(ref val) = self.fi_id { val.validate()? }
		Ok(())
	}
}


// Party52Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Party52Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgId", skip_serializing_if = "Option::is_none") )]
	pub org_id: Option<OrganisationIdentification39>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvtId", skip_serializing_if = "Option::is_none") )]
	pub prvt_id: Option<PersonIdentification18>,
}

impl Party52Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.org_id { val.validate()? }
		if let Some(ref val) = self.prvt_id { val.validate()? }
		Ok(())
	}
}


// Party53Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Party53Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgId", skip_serializing_if = "Option::is_none") )]
	pub org_id: Option<OrganisationIdentification40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvtId", skip_serializing_if = "Option::is_none") )]
	pub prvt_id: Option<PersonIdentification20>,
}

impl Party53Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.org_id { val.validate()? }
		if let Some(ref val) = self.prvt_id { val.validate()? }
		Ok(())
	}
}


// Party56Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Party56Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgId", skip_serializing_if = "Option::is_none") )]
	pub org_id: Option<OrganisationIdentification39>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FIId", skip_serializing_if = "Option::is_none") )]
	pub fi_id: Option<FinancialInstitutionIdentification19>,
}

impl Party56Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.org_id { val.validate()? }
		if let Some(ref val) = self.fi_id { val.validate()? }
		Ok(())
	}
}


// PartyAndAuthorisation6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyAndAuthorisation6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModCd", skip_serializing_if = "Option::is_none") )]
	pub mod_cd: Option<Modification1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtyOrGrp") )]
	pub pty_or_grp: PartyOrGroup3Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SgntrOrdr", skip_serializing_if = "Option::is_none") )]
	pub sgntr_ordr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Authstn") )]
	pub authstn: Authorisation2,
}

impl PartyAndAuthorisation6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mod_cd { val.validate()? }
		self.pty_or_grp.validate()?;
		if let Some(ref val) = self.sgntr_ordr {
			let pattern = Regex::new("[\\+]{0,1}[0-9]{1,15}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "sgntr_ordr does not match the required pattern".to_string()));
			}
		}
		self.authstn.validate()?;
		Ok(())
	}
}


// PartyAndAuthorisation7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyAndAuthorisation7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtyOrGrp") )]
	pub pty_or_grp: PartyOrGroup3Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SgntrOrdr", skip_serializing_if = "Option::is_none") )]
	pub sgntr_ordr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Authstn") )]
	pub authstn: Authorisation2,
}

impl PartyAndAuthorisation7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pty_or_grp.validate()?;
		if let Some(ref val) = self.sgntr_ordr {
			let pattern = Regex::new("[\\+]{0,1}[0-9]{1,15}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "sgntr_ordr does not match the required pattern".to_string()));
			}
		}
		self.authstn.validate()?;
		Ok(())
	}
}


// PartyAndCertificate6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyAndCertificate6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pty") )]
	pub pty: PartyIdentification272,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cert", skip_serializing_if = "Option::is_none") )]
	pub cert: Option<String>,
}

impl PartyAndCertificate6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pty.validate()?;
		if let Some(ref val) = self.cert {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cert is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 10240 {
				return Err(ValidationError::new(1002, "cert exceeds the maximum length of 10240".to_string()));
			}
		}
		Ok(())
	}
}


// PartyAndCertificate7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyAndCertificate7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModCd", skip_serializing_if = "Option::is_none") )]
	pub mod_cd: Option<Modification1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pty") )]
	pub pty: PartyIdentification272,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cert", skip_serializing_if = "Option::is_none") )]
	pub cert: Option<String>,
}

impl PartyAndCertificate7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mod_cd { val.validate()? }
		self.pty.validate()?;
		if let Some(ref val) = self.cert {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cert is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 10240 {
				return Err(ValidationError::new(1002, "cert exceeds the maximum length of 10240".to_string()));
			}
		}
		Ok(())
	}
}


// PartyAndSignature3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyAndSignature3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pty") )]
	pub pty: PartyIdentification135,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sgntr") )]
	pub sgntr: SkipPayload,
}

impl PartyAndSignature3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pty.validate()?;
		self.sgntr.validate()?;
		Ok(())
	}
}


// PartyAndSignature4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyAndSignature4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pty") )]
	pub pty: PartyIdentification272,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sgntr") )]
	pub sgntr: SkipPayload,
}

impl PartyAndSignature4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pty.validate()?;
		self.sgntr.validate()?;
		Ok(())
	}
}


// PartyAuditTrail2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyAuditTrail2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rcrd") )]
	pub rcrd: Vec<UpdateLogPartyRecord2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OprTmStmp") )]
	pub opr_tm_stmp: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstgUsr") )]
	pub instg_usr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ApprvgUsr", skip_serializing_if = "Option::is_none") )]
	pub apprvg_usr: Option<String>,
}

impl PartyAuditTrail2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		for item in &self.rcrd { item.validate()? }
		if self.instg_usr.chars().count() < 1 {
			return Err(ValidationError::new(1001, "instg_usr is shorter than the minimum length of 1".to_string()));
		}
		if self.instg_usr.chars().count() > 256 {
			return Err(ValidationError::new(1002, "instg_usr exceeds the maximum length of 256".to_string()));
		}
		if let Some(ref val) = self.apprvg_usr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "apprvg_usr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 256 {
				return Err(ValidationError::new(1002, "apprvg_usr exceeds the maximum length of 256".to_string()));
			}
		}
		Ok(())
	}
}


// PartyAuditTrailOrError3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyAuditTrailOrError3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtyAudtTrlRpt", skip_serializing_if = "Option::is_none") )]
	pub pty_audt_trl_rpt: Option<Vec<PartyAuditTrailReport4>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OprlErr", skip_serializing_if = "Option::is_none") )]
	pub oprl_err: Option<Vec<ErrorHandling5>>,
}

impl PartyAuditTrailOrError3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.pty_audt_trl_rpt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.oprl_err { for item in vec { item.validate()? } }
		Ok(())
	}
}


// PartyAuditTrailOrError4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyAuditTrailOrError4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AudtTrl", skip_serializing_if = "Option::is_none") )]
	pub audt_trl: Option<Vec<PartyAuditTrail2>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizErr", skip_serializing_if = "Option::is_none") )]
	pub biz_err: Option<Vec<ErrorHandling5>>,
}

impl PartyAuditTrailOrError4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.audt_trl { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.biz_err { for item in vec { item.validate()? } }
		Ok(())
	}
}


// PartyAuditTrailReport4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyAuditTrailReport4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtyAudtTrlOrErr") )]
	pub pty_audt_trl_or_err: PartyAuditTrailOrError4Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtPrd", skip_serializing_if = "Option::is_none") )]
	pub dt_prd: Option<DatePeriod3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtyId") )]
	pub pty_id: SystemPartyIdentification8,
}

impl PartyAuditTrailReport4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pty_audt_trl_or_err.validate()?;
		if let Some(ref val) = self.dt_prd { val.validate()? }
		self.pty_id.validate()?;
		Ok(())
	}
}


// PartyAuditTrailSearchCriteria2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyAuditTrailSearchCriteria2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtyId", skip_serializing_if = "Option::is_none") )]
	pub pty_id: Option<SystemPartyIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtPrd", skip_serializing_if = "Option::is_none") )]
	pub dt_prd: Option<DatePeriodSearch1Choice>,
}

impl PartyAuditTrailSearchCriteria2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.pty_id { val.validate()? }
		if let Some(ref val) = self.dt_prd { val.validate()? }
		Ok(())
	}
}


// PartyCancellation1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyCancellation1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechRcrdId", skip_serializing_if = "Option::is_none") )]
	pub tech_rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: PartyIdentification136,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl PartyCancellation1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tech_rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tech_rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tech_rcrd_id exceeds the maximum length of 35".to_string()));
			}
		}
		self.id.validate()?;
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// PartyDataReturnCriteria2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyDataReturnCriteria2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OpngDt", skip_serializing_if = "Option::is_none") )]
	pub opng_dt: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClsgDt", skip_serializing_if = "Option::is_none") )]
	pub clsg_dt: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtyId", skip_serializing_if = "Option::is_none") )]
	pub pty_id: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RspnsblPtyId", skip_serializing_if = "Option::is_none") )]
	pub rspnsbl_pty_id: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RstrctnId", skip_serializing_if = "Option::is_none") )]
	pub rstrctn_id: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RstrctdOnDt", skip_serializing_if = "Option::is_none") )]
	pub rstrctd_on_dt: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ShrtNm", skip_serializing_if = "Option::is_none") )]
	pub shrt_nm: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Adr", skip_serializing_if = "Option::is_none") )]
	pub adr: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechAdr", skip_serializing_if = "Option::is_none") )]
	pub tech_adr: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtctDtls", skip_serializing_if = "Option::is_none") )]
	pub ctct_dtls: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ResTp", skip_serializing_if = "Option::is_none") )]
	pub res_tp: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LckSts", skip_serializing_if = "Option::is_none") )]
	pub lck_sts: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktSpcfcAttr", skip_serializing_if = "Option::is_none") )]
	pub mkt_spcfc_attr: Option<bool>,
}

impl PartyDataReturnCriteria2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PartyDataSearchCriteria2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyDataSearchCriteria2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OpngDt", skip_serializing_if = "Option::is_none") )]
	pub opng_dt: Option<DatePeriodSearch1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClsgDt", skip_serializing_if = "Option::is_none") )]
	pub clsg_dt: Option<DatePeriodSearch1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<SystemPartyType1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RspnsblPtyId", skip_serializing_if = "Option::is_none") )]
	pub rspnsbl_pty_id: Option<PartyIdentification136>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtyId", skip_serializing_if = "Option::is_none") )]
	pub pty_id: Option<PartyIdentification136>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RstrctnId", skip_serializing_if = "Option::is_none") )]
	pub rstrctn_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RstrctnIsseDt", skip_serializing_if = "Option::is_none") )]
	pub rstrctn_isse_dt: Option<DateAndDateTimeSearch4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ResTp", skip_serializing_if = "Option::is_none") )]
	pub res_tp: Option<ResidenceType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LckSts", skip_serializing_if = "Option::is_none") )]
	pub lck_sts: Option<PartyLockStatus1>,
}

impl PartyDataSearchCriteria2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.opng_dt { val.validate()? }
		if let Some(ref val) = self.clsg_dt { val.validate()? }
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.rspnsbl_pty_id { val.validate()? }
		if let Some(ref val) = self.pty_id { val.validate()? }
		if let Some(ref val) = self.rstrctn_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rstrctn_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "rstrctn_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.rstrctn_isse_dt { val.validate()? }
		if let Some(ref val) = self.res_tp { val.validate()? }
		if let Some(ref val) = self.lck_sts { val.validate()? }
		Ok(())
	}
}


// PartyDetail1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyDetail1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FullNm", skip_serializing_if = "Option::is_none") )]
	pub full_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctry", skip_serializing_if = "Option::is_none") )]
	pub ctry: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtyTp") )]
	pub pty_tp: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SprvsgAuthrty") )]
	pub sprvsg_authrty: SupervisingAuthorityIdentification1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstlAdr", skip_serializing_if = "Option::is_none") )]
	pub pstl_adr: Option<PostalAddress6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctct", skip_serializing_if = "Option::is_none") )]
	pub ctct: Option<CommunicationAddress7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cmnt", skip_serializing_if = "Option::is_none") )]
	pub cmnt: Option<String>,
}

impl PartyDetail1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.full_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "full_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "full_nm exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.ctry {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry does not match the required pattern".to_string()));
			}
		}
		if self.pty_tp.chars().count() < 1 {
			return Err(ValidationError::new(1001, "pty_tp is shorter than the minimum length of 1".to_string()));
		}
		if self.pty_tp.chars().count() > 10 {
			return Err(ValidationError::new(1002, "pty_tp exceeds the maximum length of 10".to_string()));
		}
		self.sprvsg_authrty.validate()?;
		if let Some(ref val) = self.pstl_adr { val.validate()? }
		if let Some(ref val) = self.ctct { val.validate()? }
		if let Some(ref val) = self.cmnt {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cmnt is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 20000 {
				return Err(ValidationError::new(1002, "cmnt exceeds the maximum length of 20000".to_string()));
			}
		}
		Ok(())
	}
}


// PartyExceptionType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PartyExceptionType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "AGGR") )]
	CodeAGGR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PNAL") )]
	CodePNAL,
}

impl PartyExceptionType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PartyIdentification116 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyIdentification116 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtyId") )]
	pub pty_id: OrganisationIdentification28,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LglOrg", skip_serializing_if = "Option::is_none") )]
	pub lgl_org: Option<LegalOrganisation1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxPty", skip_serializing_if = "Option::is_none") )]
	pub tax_pty: Option<TaxParty1>,
}

impl PartyIdentification116 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pty_id.validate()?;
		if let Some(ref val) = self.lgl_org { val.validate()? }
		if let Some(ref val) = self.tax_pty { val.validate()? }
		Ok(())
	}
}


// PartyIdentification118Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyIdentification118Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "LEI", skip_serializing_if = "Option::is_none") )]
	pub lei: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification168>,
}

impl PartyIdentification118Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.lei {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "lei does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// PartyIdentification120Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyIdentification120Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AnyBIC", skip_serializing_if = "Option::is_none") )]
	pub any_bic: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtryId", skip_serializing_if = "Option::is_none") )]
	pub prtry_id: Option<GenericIdentification36>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NmAndAdr", skip_serializing_if = "Option::is_none") )]
	pub nm_and_adr: Option<NameAndAddress5>,
}

impl PartyIdentification120Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.any_bic {
			let pattern = Regex::new("[A-Z0-9]{4,4}[A-Z]{2,2}[A-Z0-9]{2,2}([A-Z0-9]{3,3}){0,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "any_bic does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.prtry_id { val.validate()? }
		if let Some(ref val) = self.nm_and_adr { val.validate()? }
		Ok(())
	}
}


// PartyIdentification121Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyIdentification121Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AnyBIC", skip_serializing_if = "Option::is_none") )]
	pub any_bic: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LglNttyIdr", skip_serializing_if = "Option::is_none") )]
	pub lgl_ntty_idr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NmAndAdr", skip_serializing_if = "Option::is_none") )]
	pub nm_and_adr: Option<NameAndAddress5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtryId", skip_serializing_if = "Option::is_none") )]
	pub prtry_id: Option<GenericIdentification1>,
}

impl PartyIdentification121Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.any_bic {
			let pattern = Regex::new("[A-Z0-9]{4,4}[A-Z]{2,2}[A-Z0-9]{2,2}([A-Z0-9]{3,3}){0,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "any_bic does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.lgl_ntty_idr {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "lgl_ntty_idr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.nm_and_adr { val.validate()? }
		if let Some(ref val) = self.prtry_id { val.validate()? }
		Ok(())
	}
}


// PartyIdentification125Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyIdentification125Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AnyBIC", skip_serializing_if = "Option::is_none") )]
	pub any_bic: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtryId", skip_serializing_if = "Option::is_none") )]
	pub prtry_id: Option<GenericIdentification1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NmAndAdr", skip_serializing_if = "Option::is_none") )]
	pub nm_and_adr: Option<NameAndAddress5>,
}

impl PartyIdentification125Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.any_bic {
			let pattern = Regex::new("[A-Z0-9]{4,4}[A-Z]{2,2}[A-Z0-9]{2,2}([A-Z0-9]{3,3}){0,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "any_bic does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.prtry_id { val.validate()? }
		if let Some(ref val) = self.nm_and_adr { val.validate()? }
		Ok(())
	}
}


// PartyIdentification127Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyIdentification127Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AnyBIC", skip_serializing_if = "Option::is_none") )]
	pub any_bic: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtryId", skip_serializing_if = "Option::is_none") )]
	pub prtry_id: Option<GenericIdentification36>,
}

impl PartyIdentification127Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.any_bic {
			let pattern = Regex::new("[A-Z0-9]{4,4}[A-Z]{2,2}[A-Z0-9]{2,2}([A-Z0-9]{3,3}){0,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "any_bic does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.prtry_id { val.validate()? }
		Ok(())
	}
}


// PartyIdentification135 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyIdentification135 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstlAdr", skip_serializing_if = "Option::is_none") )]
	pub pstl_adr: Option<PostalAddress24>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<Party38Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtryOfRes", skip_serializing_if = "Option::is_none") )]
	pub ctry_of_res: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtctDtls", skip_serializing_if = "Option::is_none") )]
	pub ctct_dtls: Option<Contact4>,
}

impl PartyIdentification135 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.pstl_adr { val.validate()? }
		if let Some(ref val) = self.id { val.validate()? }
		if let Some(ref val) = self.ctry_of_res {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry_of_res does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.ctct_dtls { val.validate()? }
		Ok(())
	}
}


// PartyIdentification136 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyIdentification136 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: PartyIdentification120Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LEI", skip_serializing_if = "Option::is_none") )]
	pub lei: Option<String>,
}

impl PartyIdentification136 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.id.validate()?;
		if let Some(ref val) = self.lei {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "lei does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// PartyIdentification139 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyIdentification139 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pty") )]
	pub pty: PartyIdentification125Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LEI", skip_serializing_if = "Option::is_none") )]
	pub lei: Option<String>,
}

impl PartyIdentification139 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pty.validate()?;
		if let Some(ref val) = self.lei {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "lei does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// PartyIdentification177Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyIdentification177Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AnyBIC", skip_serializing_if = "Option::is_none") )]
	pub any_bic: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtryId", skip_serializing_if = "Option::is_none") )]
	pub prtry_id: Option<GenericIdentification1>,
}

impl PartyIdentification177Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.any_bic {
			let pattern = Regex::new("[A-Z0-9]{4,4}[A-Z]{2,2}[A-Z0-9]{2,2}([A-Z0-9]{3,3}){0,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "any_bic does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.prtry_id { val.validate()? }
		Ok(())
	}
}


// PartyIdentification182Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyIdentification182Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AnyBIC", skip_serializing_if = "Option::is_none") )]
	pub any_bic: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtryId", skip_serializing_if = "Option::is_none") )]
	pub prtry_id: Option<GenericIdentification1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NmAndAdr", skip_serializing_if = "Option::is_none") )]
	pub nm_and_adr: Option<NameAndAddress15>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxIdNb", skip_serializing_if = "Option::is_none") )]
	pub tax_id_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtlRegnNb", skip_serializing_if = "Option::is_none") )]
	pub ntl_regn_nb: Option<String>,
}

impl PartyIdentification182Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.any_bic {
			let pattern = Regex::new("[A-Z0-9]{4,4}[A-Z]{2,2}[A-Z0-9]{2,2}([A-Z0-9]{3,3}){0,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "any_bic does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.prtry_id { val.validate()? }
		if let Some(ref val) = self.nm_and_adr { val.validate()? }
		if let Some(ref val) = self.tax_id_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tax_id_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tax_id_nb exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.ntl_regn_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ntl_regn_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "ntl_regn_nb exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// PartyIdentification220 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyIdentification220 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<PartyIdentification182Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LglNttyIdr", skip_serializing_if = "Option::is_none") )]
	pub lgl_ntty_idr: Option<String>,
}

impl PartyIdentification220 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.id { val.validate()? }
		if let Some(ref val) = self.lgl_ntty_idr {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "lgl_ntty_idr does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// PartyIdentification236Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyIdentification236Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Lgl", skip_serializing_if = "Option::is_none") )]
	pub lgl: Option<OrganisationIdentification15Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ntrl", skip_serializing_if = "Option::is_none") )]
	pub ntrl: Option<NaturalPersonIdentification2>,
}

impl PartyIdentification236Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.lgl { val.validate()? }
		if let Some(ref val) = self.ntrl { val.validate()? }
		Ok(())
	}
}


// PartyIdentification242Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyIdentification242Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NmAndAdr", skip_serializing_if = "Option::is_none") )]
	pub nm_and_adr: Option<NameAndAddress8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AnyBIC", skip_serializing_if = "Option::is_none") )]
	pub any_bic: Option<PartyIdentification265>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtyId", skip_serializing_if = "Option::is_none") )]
	pub pty_id: Option<PartyIdentification266>,
}

impl PartyIdentification242Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nm_and_adr { val.validate()? }
		if let Some(ref val) = self.any_bic { val.validate()? }
		if let Some(ref val) = self.pty_id { val.validate()? }
		Ok(())
	}
}


// PartyIdentification248Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyIdentification248Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Lgl", skip_serializing_if = "Option::is_none") )]
	pub lgl: Option<LegalPersonIdentification1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ntrl", skip_serializing_if = "Option::is_none") )]
	pub ntrl: Option<NaturalPersonIdentification3>,
}

impl PartyIdentification248Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.lgl { val.validate()? }
		if let Some(ref val) = self.ntrl { val.validate()? }
		Ok(())
	}
}


// PartyIdentification265 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyIdentification265 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AnyBIC") )]
	pub any_bic: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AltrntvIdr", skip_serializing_if = "Option::is_none") )]
	pub altrntv_idr: Option<Vec<String>>,
}

impl PartyIdentification265 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z0-9]{4,4}[A-Z]{2,2}[A-Z0-9]{2,2}([A-Z0-9]{3,3}){0,1}").unwrap();
		if !pattern.is_match(&self.any_bic) {
			return Err(ValidationError::new(1005, "any_bic does not match the required pattern".to_string()));
		}
		if let Some(ref vec) = self.altrntv_idr {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "altrntv_idr is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 35 {
					return Err(ValidationError::new(1002, "altrntv_idr exceeds the maximum length of 35".to_string()));
				}
			}
		}
		Ok(())
	}
}


// PartyIdentification266 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyIdentification266 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtyNm", skip_serializing_if = "Option::is_none") )]
	pub pty_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AnyBIC", skip_serializing_if = "Option::is_none") )]
	pub any_bic: Option<PartyIdentification265>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctNb", skip_serializing_if = "Option::is_none") )]
	pub acct_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Adr", skip_serializing_if = "Option::is_none") )]
	pub adr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrSysId", skip_serializing_if = "Option::is_none") )]
	pub clr_sys_id: Option<ClearingSystemIdentification2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LglNttyIdr", skip_serializing_if = "Option::is_none") )]
	pub lgl_ntty_idr: Option<String>,
}

impl PartyIdentification266 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.pty_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pty_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 34 {
				return Err(ValidationError::new(1002, "pty_nm exceeds the maximum length of 34".to_string()));
			}
		}
		if let Some(ref val) = self.any_bic { val.validate()? }
		if let Some(ref val) = self.acct_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 34 {
				return Err(ValidationError::new(1002, "acct_nb exceeds the maximum length of 34".to_string()));
			}
		}
		if let Some(ref val) = self.adr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "adr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 105 {
				return Err(ValidationError::new(1002, "adr exceeds the maximum length of 105".to_string()));
			}
		}
		if let Some(ref val) = self.clr_sys_id { val.validate()? }
		if let Some(ref val) = self.lgl_ntty_idr {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "lgl_ntty_idr does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// PartyIdentification272 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyIdentification272 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstlAdr", skip_serializing_if = "Option::is_none") )]
	pub pstl_adr: Option<PostalAddress27>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<Party52Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtryOfRes", skip_serializing_if = "Option::is_none") )]
	pub ctry_of_res: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtctDtls", skip_serializing_if = "Option::is_none") )]
	pub ctct_dtls: Option<Contact13>,
}

impl PartyIdentification272 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.pstl_adr { val.validate()? }
		if let Some(ref val) = self.id { val.validate()? }
		if let Some(ref val) = self.ctry_of_res {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry_of_res does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.ctct_dtls { val.validate()? }
		Ok(())
	}
}


// PartyIdentification273 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyIdentification273 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm") )]
	pub nm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LglNm", skip_serializing_if = "Option::is_none") )]
	pub lgl_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstlAdr", skip_serializing_if = "Option::is_none") )]
	pub pstl_adr: Option<PostalAddress27>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: Party56Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtryOfRes", skip_serializing_if = "Option::is_none") )]
	pub ctry_of_res: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtctDtls", skip_serializing_if = "Option::is_none") )]
	pub ctct_dtls: Option<Contact13>,
}

impl PartyIdentification273 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
		}
		if self.nm.chars().count() > 140 {
			return Err(ValidationError::new(1002, "nm exceeds the maximum length of 140".to_string()));
		}
		if let Some(ref val) = self.lgl_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "lgl_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "lgl_nm exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.pstl_adr { val.validate()? }
		self.id.validate()?;
		if let Some(ref val) = self.ctry_of_res {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry_of_res does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.ctct_dtls { val.validate()? }
		Ok(())
	}
}


// PartyIdentification274 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyIdentification274 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstlAdr", skip_serializing_if = "Option::is_none") )]
	pub pstl_adr: Option<PostalAddress27>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<PersonIdentification18>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtryOfRes", skip_serializing_if = "Option::is_none") )]
	pub ctry_of_res: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtctDtls", skip_serializing_if = "Option::is_none") )]
	pub ctct_dtls: Option<Contact13>,
}

impl PartyIdentification274 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.pstl_adr { val.validate()? }
		if let Some(ref val) = self.id { val.validate()? }
		if let Some(ref val) = self.ctry_of_res {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry_of_res does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.ctct_dtls { val.validate()? }
		Ok(())
	}
}


// PartyIdentification2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyIdentification2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BICOrBEI", skip_serializing_if = "Option::is_none") )]
	pub bic_or_bei: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtryId", skip_serializing_if = "Option::is_none") )]
	pub prtry_id: Option<GenericIdentification1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NmAndAdr", skip_serializing_if = "Option::is_none") )]
	pub nm_and_adr: Option<NameAndAddress5>,
}

impl PartyIdentification2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.bic_or_bei {
			let pattern = Regex::new("[A-Z]{6,6}[A-Z2-9][A-NP-Z0-9]([A-Z0-9]{3,3}){0,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "bic_or_bei does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.prtry_id { val.validate()? }
		if let Some(ref val) = self.nm_and_adr { val.validate()? }
		Ok(())
	}
}


// PartyIdentification43 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyIdentification43 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstlAdr", skip_serializing_if = "Option::is_none") )]
	pub pstl_adr: Option<PostalAddress6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<Party11Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtryOfRes", skip_serializing_if = "Option::is_none") )]
	pub ctry_of_res: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtctDtls", skip_serializing_if = "Option::is_none") )]
	pub ctct_dtls: Option<ContactDetails2>,
}

impl PartyIdentification43 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.pstl_adr { val.validate()? }
		if let Some(ref val) = self.id { val.validate()? }
		if let Some(ref val) = self.ctry_of_res {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry_of_res does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.ctct_dtls { val.validate()? }
		Ok(())
	}
}


// PartyIdentification44 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyIdentification44 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AnyBIC") )]
	pub any_bic: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AltrntvIdr", skip_serializing_if = "Option::is_none") )]
	pub altrntv_idr: Option<Vec<String>>,
}

impl PartyIdentification44 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{6,6}[A-Z2-9][A-NP-Z0-9]([A-Z0-9]{3,3}){0,1}").unwrap();
		if !pattern.is_match(&self.any_bic) {
			return Err(ValidationError::new(1005, "any_bic does not match the required pattern".to_string()));
		}
		if let Some(ref vec) = self.altrntv_idr {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "altrntv_idr is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 35 {
					return Err(ValidationError::new(1002, "altrntv_idr exceeds the maximum length of 35".to_string()));
				}
			}
		}
		Ok(())
	}
}


// PartyIdentification59 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyIdentification59 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtyNm", skip_serializing_if = "Option::is_none") )]
	pub pty_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AnyBIC", skip_serializing_if = "Option::is_none") )]
	pub any_bic: Option<PartyIdentification44>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctNb", skip_serializing_if = "Option::is_none") )]
	pub acct_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Adr", skip_serializing_if = "Option::is_none") )]
	pub adr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrSysId", skip_serializing_if = "Option::is_none") )]
	pub clr_sys_id: Option<ClearingSystemIdentification2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LglNttyIdr", skip_serializing_if = "Option::is_none") )]
	pub lgl_ntty_idr: Option<String>,
}

impl PartyIdentification59 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.pty_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pty_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 34 {
				return Err(ValidationError::new(1002, "pty_nm exceeds the maximum length of 34".to_string()));
			}
		}
		if let Some(ref val) = self.any_bic { val.validate()? }
		if let Some(ref val) = self.acct_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 34 {
				return Err(ValidationError::new(1002, "acct_nb exceeds the maximum length of 34".to_string()));
			}
		}
		if let Some(ref val) = self.adr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "adr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 105 {
				return Err(ValidationError::new(1002, "adr exceeds the maximum length of 105".to_string()));
			}
		}
		if let Some(ref val) = self.clr_sys_id { val.validate()? }
		if let Some(ref val) = self.lgl_ntty_idr {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "lgl_ntty_idr does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// PartyIdentification62 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyIdentification62 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BICFI", skip_serializing_if = "Option::is_none") )]
	pub bicfi: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtryId", skip_serializing_if = "Option::is_none") )]
	pub prtry_id: Option<GenericIdentification1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NmAndAdr", skip_serializing_if = "Option::is_none") )]
	pub nm_and_adr: Option<NameAndAddress5>,
}

impl PartyIdentification62 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.bicfi {
			let pattern = Regex::new("[A-Z]{6,6}[A-Z2-9][A-NP-Z0-9]([A-Z0-9]{3,3}){0,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "bicfi does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.prtry_id { val.validate()? }
		if let Some(ref val) = self.nm_and_adr { val.validate()? }
		Ok(())
	}
}


// PartyIdentification63 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyIdentification63 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtyId") )]
	pub pty_id: PartyIdentification75Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrcgId", skip_serializing_if = "Option::is_none") )]
	pub prcg_id: Option<String>,
}

impl PartyIdentification63 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pty_id.validate()?;
		if let Some(ref val) = self.prcg_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prcg_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prcg_id exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// PartyIdentification64 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyIdentification64 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AnyBIC", skip_serializing_if = "Option::is_none") )]
	pub any_bic: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtryId", skip_serializing_if = "Option::is_none") )]
	pub prtry_id: Option<GenericIdentification1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NmAndAdr", skip_serializing_if = "Option::is_none") )]
	pub nm_and_adr: Option<NameAndAddress5>,
}

impl PartyIdentification64 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.any_bic {
			let pattern = Regex::new("[A-Z]{6,6}[A-Z2-9][A-NP-Z0-9]([A-Z0-9]{3,3}){0,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "any_bic does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.prtry_id { val.validate()? }
		if let Some(ref val) = self.nm_and_adr { val.validate()? }
		Ok(())
	}
}


// PartyIdentification71Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyIdentification71Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AnyBIC", skip_serializing_if = "Option::is_none") )]
	pub any_bic: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtryId", skip_serializing_if = "Option::is_none") )]
	pub prtry_id: Option<GenericIdentification36>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NmAndAdr", skip_serializing_if = "Option::is_none") )]
	pub nm_and_adr: Option<NameAndAddress5>,
}

impl PartyIdentification71Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.any_bic {
			let pattern = Regex::new("[A-Z]{6,6}[A-Z2-9][A-NP-Z0-9]([A-Z0-9]{3,3}){0,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "any_bic does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.prtry_id { val.validate()? }
		if let Some(ref val) = self.nm_and_adr { val.validate()? }
		Ok(())
	}
}


// PartyIdentification72 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyIdentification72 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtyId") )]
	pub pty_id: PartyIdentification43,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LglOrg", skip_serializing_if = "Option::is_none") )]
	pub lgl_org: Option<LegalOrganisation1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxPty", skip_serializing_if = "Option::is_none") )]
	pub tax_pty: Option<TaxParty1>,
}

impl PartyIdentification72 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pty_id.validate()?;
		if let Some(ref val) = self.lgl_org { val.validate()? }
		if let Some(ref val) = self.tax_pty { val.validate()? }
		Ok(())
	}
}


// PartyIdentification73Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyIdentification73Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NmAndAdr", skip_serializing_if = "Option::is_none") )]
	pub nm_and_adr: Option<NameAndAddress8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AnyBIC", skip_serializing_if = "Option::is_none") )]
	pub any_bic: Option<PartyIdentification44>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtyId", skip_serializing_if = "Option::is_none") )]
	pub pty_id: Option<PartyIdentification59>,
}

impl PartyIdentification73Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nm_and_adr { val.validate()? }
		if let Some(ref val) = self.any_bic { val.validate()? }
		if let Some(ref val) = self.pty_id { val.validate()? }
		Ok(())
	}
}


// PartyIdentification75Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyIdentification75Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AnyBIC", skip_serializing_if = "Option::is_none") )]
	pub any_bic: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NmAndAdr", skip_serializing_if = "Option::is_none") )]
	pub nm_and_adr: Option<NameAndAddress5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctry", skip_serializing_if = "Option::is_none") )]
	pub ctry: Option<String>,
}

impl PartyIdentification75Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.any_bic {
			let pattern = Regex::new("[A-Z]{6,6}[A-Z2-9][A-NP-Z0-9]([A-Z0-9]{3,3}){0,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "any_bic does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.nm_and_adr { val.validate()? }
		if let Some(ref val) = self.ctry {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// PartyIdentification76 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyIdentification76 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: PersonOrOrganisation1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtryOfBrnch", skip_serializing_if = "Option::is_none") )]
	pub ctry_of_brnch: Option<String>,
}

impl PartyIdentification76 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.id.validate()?;
		if let Some(ref val) = self.ctry_of_brnch {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry_of_brnch does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// PartyIdentification79 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyIdentification79 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctOwnr") )]
	pub acct_ownr: Vec<PartyIdentification76>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DcsnMakr", skip_serializing_if = "Option::is_none") )]
	pub dcsn_makr: Option<Vec<PersonOrOrganisation2Choice>>,
}

impl PartyIdentification79 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		for item in &self.acct_ownr { item.validate()? }
		if let Some(ref vec) = self.dcsn_makr { for item in vec { item.validate()? } }
		Ok(())
	}
}


// PartyIdentification99Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyIdentification99Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NmAndAdr", skip_serializing_if = "Option::is_none") )]
	pub nm_and_adr: Option<NameAndAddress8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AnyBIC", skip_serializing_if = "Option::is_none") )]
	pub any_bic: Option<PartyIdentification44>,
}

impl PartyIdentification99Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nm_and_adr { val.validate()? }
		if let Some(ref val) = self.any_bic { val.validate()? }
		Ok(())
	}
}


// PartyIdentificationAndAccount95 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyIdentificationAndAccount95 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtyId") )]
	pub pty_id: PartyIdentification71Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctId", skip_serializing_if = "Option::is_none") )]
	pub acct_id: Option<SecuritiesAccount22>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrcgId", skip_serializing_if = "Option::is_none") )]
	pub prcg_id: Option<String>,
}

impl PartyIdentificationAndAccount95 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pty_id.validate()?;
		if let Some(ref val) = self.acct_id { val.validate()? }
		if let Some(ref val) = self.prcg_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prcg_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prcg_id exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// PartyIdentificationAndAccount96 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyIdentificationAndAccount96 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtyId") )]
	pub pty_id: PartyIdentification64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctId") )]
	pub acct_id: AccountIdentification26,
}

impl PartyIdentificationAndAccount96 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pty_id.validate()?;
		self.acct_id.validate()?;
		Ok(())
	}
}


// PartyIdentificationAndAccount97 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyIdentificationAndAccount97 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtyId") )]
	pub pty_id: PartyIdentification62,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctId", skip_serializing_if = "Option::is_none") )]
	pub acct_id: Option<AccountIdentification26>,
}

impl PartyIdentificationAndAccount97 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pty_id.validate()?;
		if let Some(ref val) = self.acct_id { val.validate()? }
		Ok(())
	}
}


// PartyIdentificationType7Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PartyIdentificationType7Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ATIN") )]
	CodeATIN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IDCD") )]
	CodeIDCD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NRIN") )]
	CodeNRIN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PASS") )]
	CodePASS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "POCD") )]
	CodePOCD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SOCS") )]
	CodeSOCS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SRSA") )]
	CodeSRSA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GUNL") )]
	CodeGUNL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GTIN") )]
	CodeGTIN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ITIN") )]
	CodeITIN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CPFA") )]
	CodeCPFA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AREG") )]
	CodeAREG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DRLC") )]
	CodeDRLC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EMID") )]
	CodeEMID,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NINV") )]
	CodeNINV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INCL") )]
	CodeINCL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GIIN") )]
	CodeGIIN,
}

impl PartyIdentificationType7Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PartyLockStatus1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyLockStatus1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldFr", skip_serializing_if = "Option::is_none") )]
	pub vld_fr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts") )]
	pub sts: LockStatus1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LckRsn", skip_serializing_if = "Option::is_none") )]
	pub lck_rsn: Option<Vec<String>>,
}

impl PartyLockStatus1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.sts.validate()?;
		if let Some(ref vec) = self.lck_rsn {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "lck_rsn is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 35 {
					return Err(ValidationError::new(1002, "lck_rsn exceeds the maximum length of 35".to_string()));
				}
			}
		}
		Ok(())
	}
}


// PartyModification3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyModification3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModCd", skip_serializing_if = "Option::is_none") )]
	pub mod_cd: Option<Modification1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtyId") )]
	pub pty_id: PartyIdentification274,
}

impl PartyModification3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mod_cd { val.validate()? }
		self.pty_id.validate()?;
		Ok(())
	}
}


// PartyName3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyName3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldFr", skip_serializing_if = "Option::is_none") )]
	pub vld_fr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ShrtNm", skip_serializing_if = "Option::is_none") )]
	pub shrt_nm: Option<String>,
}

impl PartyName3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.shrt_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "shrt_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "shrt_nm exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// PartyName4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyName4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldFr", skip_serializing_if = "Option::is_none") )]
	pub vld_fr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm") )]
	pub nm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ShrtNm", skip_serializing_if = "Option::is_none") )]
	pub shrt_nm: Option<String>,
}

impl PartyName4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
		}
		if self.nm.chars().count() > 350 {
			return Err(ValidationError::new(1002, "nm exceeds the maximum length of 350".to_string()));
		}
		if let Some(ref val) = self.shrt_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "shrt_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "shrt_nm exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// PartyNatureType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PartyNatureType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NFIN") )]
	CodeNFIN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FIIN") )]
	CodeFIIN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CCPS") )]
	CodeCCPS,
}

impl PartyNatureType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PartyOrBusinessError4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyOrBusinessError4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SysPty", skip_serializing_if = "Option::is_none") )]
	pub sys_pty: Option<SystemParty6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizErr", skip_serializing_if = "Option::is_none") )]
	pub biz_err: Option<Vec<ErrorHandling4>>,
}

impl PartyOrBusinessError4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.sys_pty { val.validate()? }
		if let Some(ref vec) = self.biz_err { for item in vec { item.validate()? } }
		Ok(())
	}
}


// PartyOrCurrency1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyOrCurrency1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dpstry", skip_serializing_if = "Option::is_none") )]
	pub dpstry: Option<PartyIdentification63>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmCcy", skip_serializing_if = "Option::is_none") )]
	pub sttlm_ccy: Option<String>,
}

impl PartyOrCurrency1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.dpstry { val.validate()? }
		if let Some(ref val) = self.sttlm_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "sttlm_ccy does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// PartyOrGroup3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyOrGroup3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "GrpId", skip_serializing_if = "Option::is_none") )]
	pub grp_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pty", skip_serializing_if = "Option::is_none") )]
	pub pty: Option<PartyAndCertificate6>,
}

impl PartyOrGroup3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.grp_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "grp_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "grp_id exceeds the maximum length of 4".to_string()));
			}
			let pattern = Regex::new("[a-zA-Z0-9]{1,4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "grp_id does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.pty { val.validate()? }
		Ok(())
	}
}


// PartyOrOperationalError4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyOrOperationalError4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtyRpt", skip_serializing_if = "Option::is_none") )]
	pub pty_rpt: Option<Vec<PartyReport4>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OprlErr", skip_serializing_if = "Option::is_none") )]
	pub oprl_err: Option<Vec<ErrorHandling5>>,
}

impl PartyOrOperationalError4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.pty_rpt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.oprl_err { for item in vec { item.validate()? } }
		Ok(())
	}
}


// PartyProfileInformation5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyProfileInformation5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CertfctnInd", skip_serializing_if = "Option::is_none") )]
	pub certfctn_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldtngPty", skip_serializing_if = "Option::is_none") )]
	pub vldtng_pty: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChckngPty", skip_serializing_if = "Option::is_none") )]
	pub chckng_pty: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RspnsblPty", skip_serializing_if = "Option::is_none") )]
	pub rspnsbl_pty: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CertTp", skip_serializing_if = "Option::is_none") )]
	pub cert_tp: Option<CertificationType1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChckngDt", skip_serializing_if = "Option::is_none") )]
	pub chckng_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChckngFrqcy", skip_serializing_if = "Option::is_none") )]
	pub chckng_frqcy: Option<EventFrequency1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NxtRvsnDt", skip_serializing_if = "Option::is_none") )]
	pub nxt_rvsn_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SlryRg", skip_serializing_if = "Option::is_none") )]
	pub slry_rg: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SrcOfWlth", skip_serializing_if = "Option::is_none") )]
	pub src_of_wlth: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CstmrCndctClssfctn", skip_serializing_if = "Option::is_none") )]
	pub cstmr_cndct_clssfctn: Option<CustomerConductClassification1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RskLvl", skip_serializing_if = "Option::is_none") )]
	pub rsk_lvl: Option<RiskLevel2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "KnowYourCstmrChckTp", skip_serializing_if = "Option::is_none") )]
	pub know_your_cstmr_chck_tp: Option<KYCCheckType1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "KnowYourCstmrDBChck", skip_serializing_if = "Option::is_none") )]
	pub know_your_cstmr_db_chck: Option<DataBaseCheck1>,
}

impl PartyProfileInformation5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.vldtng_pty {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "vldtng_pty is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "vldtng_pty exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.chckng_pty {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "chckng_pty is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "chckng_pty exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.rspnsbl_pty {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rspnsbl_pty is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "rspnsbl_pty exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.cert_tp { val.validate()? }
		if let Some(ref val) = self.chckng_frqcy { val.validate()? }
		if let Some(ref val) = self.slry_rg {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "slry_rg is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "slry_rg exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.src_of_wlth {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "src_of_wlth is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "src_of_wlth exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.cstmr_cndct_clssfctn { val.validate()? }
		if let Some(ref val) = self.rsk_lvl { val.validate()? }
		if let Some(ref val) = self.know_your_cstmr_chck_tp { val.validate()? }
		if let Some(ref val) = self.know_your_cstmr_db_chck { val.validate()? }
		Ok(())
	}
}


// PartyReferenceDataChange3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyReferenceDataChange3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtyId") )]
	pub pty_id: SystemPartyIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rcrd") )]
	pub rcrd: Vec<UpdateLogPartyRecord2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OprTmStmp") )]
	pub opr_tm_stmp: String,
}

impl PartyReferenceDataChange3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pty_id.validate()?;
		for item in &self.rcrd { item.validate()? }
		Ok(())
	}
}


// PartyReport1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyReport1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Upd", skip_serializing_if = "Option::is_none") )]
	pub upd: Option<PartyUpdate1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cxl", skip_serializing_if = "Option::is_none") )]
	pub cxl: Option<PartyCancellation1>,
}

impl PartyReport1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.upd { val.validate()? }
		if let Some(ref val) = self.cxl { val.validate()? }
		Ok(())
	}
}


// PartyReport4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyReport4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtyId") )]
	pub pty_id: SystemPartyIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtyOrErr") )]
	pub pty_or_err: PartyOrBusinessError4Choice,
}

impl PartyReport4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pty_id.validate()?;
		self.pty_or_err.validate()?;
		Ok(())
	}
}


// PartyRole1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PartyRole1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CUST") )]
	CodeCUST,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INVS") )]
	CodeINVS,
}

impl PartyRole1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PartyRole2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyRole2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<InvestmentFundRole6Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl PartyRole2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// PartyRole4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyRole4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<InvestmentFundRole7Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl PartyRole4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// PartyRole5Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyRole5Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<PartyRole1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl PartyRole5Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// PartyStatement3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyStatement3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SysDt") )]
	pub sys_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Chng", skip_serializing_if = "Option::is_none") )]
	pub chng: Option<Vec<PartyReferenceDataChange3>>,
}

impl PartyStatement3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.chng { for item in vec { item.validate()? } }
		Ok(())
	}
}


// PartyStatus2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyStatus2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts") )]
	pub sts: Status6Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsRsn", skip_serializing_if = "Option::is_none") )]
	pub sts_rsn: Option<Vec<StatusReasonInformation10>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SysPtyId", skip_serializing_if = "Option::is_none") )]
	pub sys_pty_id: Option<SystemPartyIdentification8>,
}

impl PartyStatus2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.sts.validate()?;
		if let Some(ref vec) = self.sts_rsn { for item in vec { item.validate()? } }
		if let Some(ref val) = self.sys_pty_id { val.validate()? }
		Ok(())
	}
}


// PartyType3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PartyType3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "OPOI") )]
	CodeOPOI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MERC") )]
	CodeMERC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACCP") )]
	CodeACCP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ITAG") )]
	CodeITAG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACQR") )]
	CodeACQR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CISS") )]
	CodeCISS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DLIS") )]
	CodeDLIS,
}

impl PartyType3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PartyType4Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PartyType4Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "MERC") )]
	CodeMERC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACCP") )]
	CodeACCP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ITAG") )]
	CodeITAG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACQR") )]
	CodeACQR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CISS") )]
	CodeCISS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TAXH") )]
	CodeTAXH,
}

impl PartyType4Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PartyUpdate1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PartyUpdate1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechRcrdId", skip_serializing_if = "Option::is_none") )]
	pub tech_rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: PartyIdentification136,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsId", skip_serializing_if = "Option::is_none") )]
	pub prvs_id: Option<PartyIdentification136>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr") )]
	pub othr: PartyDetail1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts") )]
	pub sts: Vec<StatusDetail1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechVldtyPrd", skip_serializing_if = "Option::is_none") )]
	pub tech_vldty_prd: Option<Period4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl PartyUpdate1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tech_rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tech_rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tech_rcrd_id exceeds the maximum length of 35".to_string()));
			}
		}
		self.id.validate()?;
		if let Some(ref val) = self.prvs_id { val.validate()? }
		self.othr.validate()?;
		for item in &self.sts { item.validate()? }
		if let Some(ref val) = self.tech_vldty_prd { val.validate()? }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// PassiveOrAgressiveType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PassiveOrAgressiveType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "AGRE") )]
	CodeAGRE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PASV") )]
	CodePASV,
}

impl PassiveOrAgressiveType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PayInCallItem ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PayInCallItem {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveOrHistoricCurrencyAndAmount,
}

impl PayInCallItem {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.amt.validate()?;
		Ok(())
	}
}


// PayInFactors1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PayInFactors1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AggtShrtPosLmt") )]
	pub aggt_shrt_pos_lmt: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CcyFctrs") )]
	pub ccy_fctrs: Vec<CurrencyFactors1>,
}

impl PayInFactors1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.aggt_shrt_pos_lmt.validate()?;
		for item in &self.ccy_fctrs { item.validate()? }
		Ok(())
	}
}


// PayInScheduleItems1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PayInScheduleItems1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ddln") )]
	pub ddln: String,
}

impl PayInScheduleItems1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.amt.validate()?;
		Ok(())
	}
}


// PayloadData2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PayloadData2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PyldIdr") )]
	pub pyld_idr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtAndTm") )]
	pub cre_dt_and_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PssblDplctFlg", skip_serializing_if = "Option::is_none") )]
	pub pssbl_dplct_flg: Option<bool>,
}

impl PayloadData2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.pyld_idr.chars().count() < 1 {
			return Err(ValidationError::new(1001, "pyld_idr is shorter than the minimum length of 1".to_string()));
		}
		if self.pyld_idr.chars().count() > 35 {
			return Err(ValidationError::new(1002, "pyld_idr exceeds the maximum length of 35".to_string()));
		}
		Ok(())
	}
}


// PayloadDescription2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PayloadDescription2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PyldData") )]
	pub pyld_data: PayloadData2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ApplSpcfcs", skip_serializing_if = "Option::is_none") )]
	pub appl_spcfcs: Option<ApplicationSpecifics1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PyldTp") )]
	pub pyld_tp: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MnfstData", skip_serializing_if = "Option::is_none") )]
	pub mnfst_data: Option<Vec<ManifestData2>>,
}

impl PayloadDescription2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pyld_data.validate()?;
		if let Some(ref val) = self.appl_spcfcs { val.validate()? }
		if self.pyld_tp.chars().count() < 1 {
			return Err(ValidationError::new(1001, "pyld_tp is shorter than the minimum length of 1".to_string()));
		}
		if self.pyld_tp.chars().count() > 256 {
			return Err(ValidationError::new(1002, "pyld_tp exceeds the maximum length of 256".to_string()));
		}
		if let Some(ref vec) = self.mnfst_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// PaymentAccount4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentAccount4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ccy") )]
	pub ccy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NetPmt") )]
	pub net_pmt: AmountAndDirection86,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GrssCdts") )]
	pub grss_cdts: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GrssDbts") )]
	pub grss_dbts: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LatePmtConf") )]
	pub late_pmt_conf: String,
}

impl PaymentAccount4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.ccy) {
			return Err(ValidationError::new(1005, "ccy does not match the required pattern".to_string()));
		}
		self.net_pmt.validate()?;
		let pattern = Regex::new("[0-9]{1,10}").unwrap();
		if !pattern.is_match(&self.late_pmt_conf) {
			return Err(ValidationError::new(1005, "late_pmt_conf does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// PaymentCancellationReason6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentCancellationReason6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Orgtr", skip_serializing_if = "Option::is_none") )]
	pub orgtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<CancellationReason33Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<Vec<String>>,
}

impl PaymentCancellationReason6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgtr { val.validate()? }
		if let Some(ref val) = self.rsn { val.validate()? }
		if let Some(ref vec) = self.addtl_inf {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 105 {
					return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 105".to_string()));
				}
			}
		}
		Ok(())
	}
}


// PaymentCard29 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentCard29 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: CardType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nb") )]
	pub nb: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HldrNm") )]
	pub hldr_nm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StartDt", skip_serializing_if = "Option::is_none") )]
	pub start_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XpryDt") )]
	pub xpry_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CardIssrNm", skip_serializing_if = "Option::is_none") )]
	pub card_issr_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CardIssrId", skip_serializing_if = "Option::is_none") )]
	pub card_issr_id: Option<PartyIdentification125Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctyCd", skip_serializing_if = "Option::is_none") )]
	pub scty_cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SeqNb", skip_serializing_if = "Option::is_none") )]
	pub seq_nb: Option<String>,
}

impl PaymentCard29 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tp.validate()?;
		if self.nb.chars().count() < 1 {
			return Err(ValidationError::new(1001, "nb is shorter than the minimum length of 1".to_string()));
		}
		if self.nb.chars().count() > 35 {
			return Err(ValidationError::new(1002, "nb exceeds the maximum length of 35".to_string()));
		}
		if self.hldr_nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "hldr_nm is shorter than the minimum length of 1".to_string()));
		}
		if self.hldr_nm.chars().count() > 35 {
			return Err(ValidationError::new(1002, "hldr_nm exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.card_issr_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "card_issr_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "card_issr_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.card_issr_id { val.validate()? }
		if let Some(ref val) = self.scty_cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "scty_cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "scty_cd exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.seq_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "seq_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 3 {
				return Err(ValidationError::new(1002, "seq_nb exceeds the maximum length of 3".to_string()));
			}
		}
		Ok(())
	}
}


// PaymentCard4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentCard4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PlainCardData", skip_serializing_if = "Option::is_none") )]
	pub plain_card_data: Option<PlainCardData1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CardCtryCd", skip_serializing_if = "Option::is_none") )]
	pub card_ctry_cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CardBrnd", skip_serializing_if = "Option::is_none") )]
	pub card_brnd: Option<GenericIdentification1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlCardData", skip_serializing_if = "Option::is_none") )]
	pub addtl_card_data: Option<String>,
}

impl PaymentCard4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.plain_card_data { val.validate()? }
		if let Some(ref val) = self.card_ctry_cd {
			let pattern = Regex::new("[0-9]{3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "card_ctry_cd does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.card_brnd { val.validate()? }
		if let Some(ref val) = self.addtl_card_data {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_card_data is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "addtl_card_data exceeds the maximum length of 70".to_string()));
			}
		}
		Ok(())
	}
}


// PaymentCommon6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentCommon6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtFr", skip_serializing_if = "Option::is_none") )]
	pub pmt_fr: Option<System3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtTo", skip_serializing_if = "Option::is_none") )]
	pub pmt_to: Option<System3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CmonSts", skip_serializing_if = "Option::is_none") )]
	pub cmon_sts: Option<Vec<PaymentStatus6>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdExctnDt", skip_serializing_if = "Option::is_none") )]
	pub reqd_exctn_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtryDt", skip_serializing_if = "Option::is_none") )]
	pub ntry_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbtInd", skip_serializing_if = "Option::is_none") )]
	pub cdt_dbt_ind: Option<CreditDebitCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtMtd", skip_serializing_if = "Option::is_none") )]
	pub pmt_mtd: Option<PaymentOrigin1Choice>,
}

impl PaymentCommon6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.pmt_fr { val.validate()? }
		if let Some(ref val) = self.pmt_to { val.validate()? }
		if let Some(ref vec) = self.cmon_sts { for item in vec { item.validate()? } }
		if let Some(ref val) = self.reqd_exctn_dt { val.validate()? }
		if let Some(ref val) = self.ntry_dt { val.validate()? }
		if let Some(ref val) = self.cdt_dbt_ind { val.validate()? }
		if let Some(ref val) = self.pmt_mtd { val.validate()? }
		Ok(())
	}
}


// PaymentComplementaryInformation11 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentComplementaryInformation11 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrId", skip_serializing_if = "Option::is_none") )]
	pub instr_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndToEndId", skip_serializing_if = "Option::is_none") )]
	pub end_to_end_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxId", skip_serializing_if = "Option::is_none") )]
	pub tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtTpInf", skip_serializing_if = "Option::is_none") )]
	pub pmt_tp_inf: Option<PaymentTypeInformation27>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdExctnDt", skip_serializing_if = "Option::is_none") )]
	pub reqd_exctn_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdColltnDt", skip_serializing_if = "Option::is_none") )]
	pub reqd_colltn_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBkSttlmDt", skip_serializing_if = "Option::is_none") )]
	pub intr_bk_sttlm_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<AmountType4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBkSttlmAmt", skip_serializing_if = "Option::is_none") )]
	pub intr_bk_sttlm_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgBr", skip_serializing_if = "Option::is_none") )]
	pub chrg_br: Option<ChargeBearerType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtDbtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_dbtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dbtr", skip_serializing_if = "Option::is_none") )]
	pub dbtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgt", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmInf", skip_serializing_if = "Option::is_none") )]
	pub sttlm_inf: Option<SettlementInstruction15>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt1", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt1: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt1Acct", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt1_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt2", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt2: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt2Acct", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt2_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt3", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt3: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt3Acct", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt3_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgt", skip_serializing_if = "Option::is_none") )]
	pub cdtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub cdtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cdtr", skip_serializing_if = "Option::is_none") )]
	pub cdtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAcct", skip_serializing_if = "Option::is_none") )]
	pub cdtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtCdtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_cdtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Purp", skip_serializing_if = "Option::is_none") )]
	pub purp: Option<Purpose2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrForDbtrAgt", skip_serializing_if = "Option::is_none") )]
	pub instr_for_dbtr_agt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsInstgAgt1", skip_serializing_if = "Option::is_none") )]
	pub prvs_instg_agt1: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsInstgAgt1Acct", skip_serializing_if = "Option::is_none") )]
	pub prvs_instg_agt1_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsInstgAgt2", skip_serializing_if = "Option::is_none") )]
	pub prvs_instg_agt2: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsInstgAgt2Acct", skip_serializing_if = "Option::is_none") )]
	pub prvs_instg_agt2_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsInstgAgt3", skip_serializing_if = "Option::is_none") )]
	pub prvs_instg_agt3: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsInstgAgt3Acct", skip_serializing_if = "Option::is_none") )]
	pub prvs_instg_agt3_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrForNxtAgt", skip_serializing_if = "Option::is_none") )]
	pub instr_for_nxt_agt: Option<Vec<InstructionForNextAgent1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrForCdtrAgt", skip_serializing_if = "Option::is_none") )]
	pub instr_for_cdtr_agt: Option<Vec<InstructionForCreditorAgent3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdRmtInf", skip_serializing_if = "Option::is_none") )]
	pub rltd_rmt_inf: Option<Vec<RemittanceLocation8>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RmtInf", skip_serializing_if = "Option::is_none") )]
	pub rmt_inf: Option<RemittanceInformation22>,
}

impl PaymentComplementaryInformation11 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.instr_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "instr_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "instr_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.end_to_end_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "end_to_end_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "end_to_end_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.pmt_tp_inf { val.validate()? }
		if let Some(ref val) = self.reqd_exctn_dt { val.validate()? }
		if let Some(ref val) = self.amt { val.validate()? }
		if let Some(ref val) = self.intr_bk_sttlm_amt { val.validate()? }
		if let Some(ref val) = self.chrg_br { val.validate()? }
		if let Some(ref val) = self.ultmt_dbtr { val.validate()? }
		if let Some(ref val) = self.dbtr { val.validate()? }
		if let Some(ref val) = self.dbtr_acct { val.validate()? }
		if let Some(ref val) = self.dbtr_agt { val.validate()? }
		if let Some(ref val) = self.dbtr_agt_acct { val.validate()? }
		if let Some(ref val) = self.sttlm_inf { val.validate()? }
		if let Some(ref val) = self.intrmy_agt1 { val.validate()? }
		if let Some(ref val) = self.intrmy_agt1_acct { val.validate()? }
		if let Some(ref val) = self.intrmy_agt2 { val.validate()? }
		if let Some(ref val) = self.intrmy_agt2_acct { val.validate()? }
		if let Some(ref val) = self.intrmy_agt3 { val.validate()? }
		if let Some(ref val) = self.intrmy_agt3_acct { val.validate()? }
		if let Some(ref val) = self.cdtr_agt { val.validate()? }
		if let Some(ref val) = self.cdtr_agt_acct { val.validate()? }
		if let Some(ref val) = self.cdtr { val.validate()? }
		if let Some(ref val) = self.cdtr_acct { val.validate()? }
		if let Some(ref val) = self.ultmt_cdtr { val.validate()? }
		if let Some(ref val) = self.purp { val.validate()? }
		if let Some(ref val) = self.instr_for_dbtr_agt {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "instr_for_dbtr_agt is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "instr_for_dbtr_agt exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.prvs_instg_agt1 { val.validate()? }
		if let Some(ref val) = self.prvs_instg_agt1_acct { val.validate()? }
		if let Some(ref val) = self.prvs_instg_agt2 { val.validate()? }
		if let Some(ref val) = self.prvs_instg_agt2_acct { val.validate()? }
		if let Some(ref val) = self.prvs_instg_agt3 { val.validate()? }
		if let Some(ref val) = self.prvs_instg_agt3_acct { val.validate()? }
		if let Some(ref vec) = self.instr_for_nxt_agt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.instr_for_cdtr_agt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.rltd_rmt_inf { for item in vec { item.validate()? } }
		if let Some(ref val) = self.rmt_inf { val.validate()? }
		Ok(())
	}
}


// PaymentCondition2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentCondition2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AmtModAllwd", skip_serializing_if = "Option::is_none") )]
	pub amt_mod_allwd: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EarlyPmtAllwd", skip_serializing_if = "Option::is_none") )]
	pub early_pmt_allwd: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DelyPnlty", skip_serializing_if = "Option::is_none") )]
	pub dely_pnlty: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ImdtPmtRbt", skip_serializing_if = "Option::is_none") )]
	pub imdt_pmt_rbt: Option<AmountOrRate1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GrntedPmtReqd", skip_serializing_if = "Option::is_none") )]
	pub grnted_pmt_reqd: Option<bool>,
}

impl PaymentCondition2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.dely_pnlty {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "dely_pnlty is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "dely_pnlty exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.imdt_pmt_rbt { val.validate()? }
		Ok(())
	}
}


// PaymentConditionStatus2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentConditionStatus2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AccptdAmt", skip_serializing_if = "Option::is_none") )]
	pub accptd_amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GrntedPmt", skip_serializing_if = "Option::is_none") )]
	pub grnted_pmt: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EarlyPmt", skip_serializing_if = "Option::is_none") )]
	pub early_pmt: Option<bool>,
}

impl PaymentConditionStatus2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.accptd_amt { val.validate()? }
		Ok(())
	}
}


// PaymentContext3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentContext3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CardPres", skip_serializing_if = "Option::is_none") )]
	pub card_pres: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CrdhldrPres", skip_serializing_if = "Option::is_none") )]
	pub crdhldr_pres: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OnLineCntxt", skip_serializing_if = "Option::is_none") )]
	pub on_line_cntxt: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AttndncCntxt", skip_serializing_if = "Option::is_none") )]
	pub attndnc_cntxt: Option<AttendanceContext1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxEnvt", skip_serializing_if = "Option::is_none") )]
	pub tx_envt: Option<TransactionEnvironment1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxChanl", skip_serializing_if = "Option::is_none") )]
	pub tx_chanl: Option<TransactionChannel1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AttndntMsgCpbl", skip_serializing_if = "Option::is_none") )]
	pub attndnt_msg_cpbl: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AttndntLang", skip_serializing_if = "Option::is_none") )]
	pub attndnt_lang: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CardDataNtryMd") )]
	pub card_data_ntry_md: CardDataReading1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FllbckInd", skip_serializing_if = "Option::is_none") )]
	pub fllbck_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AuthntcnMtd", skip_serializing_if = "Option::is_none") )]
	pub authntcn_mtd: Option<CardholderAuthentication2>,
}

impl PaymentContext3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.attndnc_cntxt { val.validate()? }
		if let Some(ref val) = self.tx_envt { val.validate()? }
		if let Some(ref val) = self.tx_chanl { val.validate()? }
		if let Some(ref val) = self.attndnt_lang {
			let pattern = Regex::new("[a-z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "attndnt_lang does not match the required pattern".to_string()));
			}
		}
		self.card_data_ntry_md.validate()?;
		if let Some(ref val) = self.authntcn_mtd { val.validate()? }
		Ok(())
	}
}


// PaymentIdentification13 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentIdentification13 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrId", skip_serializing_if = "Option::is_none") )]
	pub instr_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndToEndId") )]
	pub end_to_end_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxId", skip_serializing_if = "Option::is_none") )]
	pub tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UETR", skip_serializing_if = "Option::is_none") )]
	pub uetr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrSysRef", skip_serializing_if = "Option::is_none") )]
	pub clr_sys_ref: Option<String>,
}

impl PaymentIdentification13 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.instr_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "instr_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "instr_id exceeds the maximum length of 35".to_string()));
			}
		}
		if self.end_to_end_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "end_to_end_id is shorter than the minimum length of 1".to_string()));
		}
		if self.end_to_end_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "end_to_end_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.uetr {
			let pattern = Regex::new("[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "uetr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.clr_sys_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "clr_sys_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "clr_sys_ref exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// PaymentIdentification15 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentIdentification15 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrId", skip_serializing_if = "Option::is_none") )]
	pub instr_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndToEndId") )]
	pub end_to_end_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxId", skip_serializing_if = "Option::is_none") )]
	pub tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UETR", skip_serializing_if = "Option::is_none") )]
	pub uetr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrSysRef", skip_serializing_if = "Option::is_none") )]
	pub clr_sys_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrstAgt", skip_serializing_if = "Option::is_none") )]
	pub frst_agt: Option<BranchAndFinancialInstitutionIdentification8>,
}

impl PaymentIdentification15 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.instr_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "instr_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "instr_id exceeds the maximum length of 35".to_string()));
			}
		}
		if self.end_to_end_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "end_to_end_id is shorter than the minimum length of 1".to_string()));
		}
		if self.end_to_end_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "end_to_end_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.uetr {
			let pattern = Regex::new("[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "uetr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.clr_sys_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "clr_sys_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "clr_sys_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.frst_agt { val.validate()? }
		Ok(())
	}
}


// PaymentIdentification6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentIdentification6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrId", skip_serializing_if = "Option::is_none") )]
	pub instr_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndToEndId") )]
	pub end_to_end_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UETR", skip_serializing_if = "Option::is_none") )]
	pub uetr: Option<String>,
}

impl PaymentIdentification6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.instr_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "instr_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "instr_id exceeds the maximum length of 35".to_string()));
			}
		}
		if self.end_to_end_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "end_to_end_id is shorter than the minimum length of 1".to_string()));
		}
		if self.end_to_end_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "end_to_end_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.uetr {
			let pattern = Regex::new("[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "uetr does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// PaymentIdentification8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentIdentification8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrId", skip_serializing_if = "Option::is_none") )]
	pub instr_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndToEndId") )]
	pub end_to_end_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxId", skip_serializing_if = "Option::is_none") )]
	pub tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UETR", skip_serializing_if = "Option::is_none") )]
	pub uetr: Option<String>,
}

impl PaymentIdentification8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.instr_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "instr_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "instr_id exceeds the maximum length of 35".to_string()));
			}
		}
		if self.end_to_end_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "end_to_end_id is shorter than the minimum length of 1".to_string()));
		}
		if self.end_to_end_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "end_to_end_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.uetr {
			let pattern = Regex::new("[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "uetr does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// PaymentIdentification8Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentIdentification8Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxId", skip_serializing_if = "Option::is_none") )]
	pub tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UETR", skip_serializing_if = "Option::is_none") )]
	pub uetr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QId", skip_serializing_if = "Option::is_none") )]
	pub q_id: Option<QueueTransactionIdentification1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LngBizId", skip_serializing_if = "Option::is_none") )]
	pub lng_biz_id: Option<LongPaymentIdentification4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ShrtBizId", skip_serializing_if = "Option::is_none") )]
	pub shrt_biz_id: Option<ShortPaymentIdentification4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtryId", skip_serializing_if = "Option::is_none") )]
	pub prtry_id: Option<String>,
}

impl PaymentIdentification8Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.uetr {
			let pattern = Regex::new("[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "uetr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.q_id { val.validate()? }
		if let Some(ref val) = self.lng_biz_id { val.validate()? }
		if let Some(ref val) = self.shrt_biz_id { val.validate()? }
		if let Some(ref val) = self.prtry_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "prtry_id exceeds the maximum length of 70".to_string()));
			}
		}
		Ok(())
	}
}


// PaymentInitiationSource1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentInitiationSource1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm") )]
	pub nm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prvdr", skip_serializing_if = "Option::is_none") )]
	pub prvdr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Vrsn", skip_serializing_if = "Option::is_none") )]
	pub vrsn: Option<String>,
}

impl PaymentInitiationSource1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
		}
		if self.nm.chars().count() > 140 {
			return Err(ValidationError::new(1002, "nm exceeds the maximum length of 140".to_string()));
		}
		if let Some(ref val) = self.prvdr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prvdr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prvdr exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.vrsn {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "vrsn is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "vrsn exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// PaymentInstruction13 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentInstruction13 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdExctnDtTm", skip_serializing_if = "Option::is_none") )]
	pub reqd_exctn_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtTp", skip_serializing_if = "Option::is_none") )]
	pub pmt_tp: Option<PaymentType4Choice>,
}

impl PaymentInstruction13 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.pmt_tp { val.validate()? }
		Ok(())
	}
}


// PaymentInstruction33 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentInstruction33 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Instr", skip_serializing_if = "Option::is_none") )]
	pub instr: Option<Instruction1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<PaymentType4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prty", skip_serializing_if = "Option::is_none") )]
	pub prty: Option<Priority1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrcgVldtyTm", skip_serializing_if = "Option::is_none") )]
	pub prcg_vldty_tm: Option<DateTimePeriod1Choice>,
}

impl PaymentInstruction33 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.instr { val.validate()? }
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.prty { val.validate()? }
		if let Some(ref val) = self.prcg_vldty_tm { val.validate()? }
		Ok(())
	}
}


// PaymentInstruction43 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentInstruction43 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtInfId") )]
	pub pmt_inf_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtMtd") )]
	pub pmt_mtd: PaymentMethod3Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BtchBookg", skip_serializing_if = "Option::is_none") )]
	pub btch_bookg: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfTxs", skip_serializing_if = "Option::is_none") )]
	pub nb_of_txs: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrlSum", skip_serializing_if = "Option::is_none") )]
	pub ctrl_sum: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtTpInf", skip_serializing_if = "Option::is_none") )]
	pub pmt_tp_inf: Option<PaymentTypeInformation26>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdExctnDt") )]
	pub reqd_exctn_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PoolgAdjstmntDt", skip_serializing_if = "Option::is_none") )]
	pub poolg_adjstmnt_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dbtr") )]
	pub dbtr: PartyIdentification272,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAcct") )]
	pub dbtr_acct: CashAccount40,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgt") )]
	pub dbtr_agt: BranchAndFinancialInstitutionIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrForDbtrAgt", skip_serializing_if = "Option::is_none") )]
	pub instr_for_dbtr_agt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtDbtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_dbtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgBr", skip_serializing_if = "Option::is_none") )]
	pub chrg_br: Option<ChargeBearerType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsAcct", skip_serializing_if = "Option::is_none") )]
	pub chrgs_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsAcctAgt", skip_serializing_if = "Option::is_none") )]
	pub chrgs_acct_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtTrfTxInf") )]
	pub cdt_trf_tx_inf: Vec<CreditTransferTransaction59>,
}

impl PaymentInstruction43 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.pmt_inf_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "pmt_inf_id is shorter than the minimum length of 1".to_string()));
		}
		if self.pmt_inf_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "pmt_inf_id exceeds the maximum length of 35".to_string()));
		}
		self.pmt_mtd.validate()?;
		if let Some(ref val) = self.nb_of_txs {
			let pattern = Regex::new("[0-9]{1,15}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "nb_of_txs does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.pmt_tp_inf { val.validate()? }
		self.dbtr.validate()?;
		self.dbtr_acct.validate()?;
		self.dbtr_agt.validate()?;
		if let Some(ref val) = self.dbtr_agt_acct { val.validate()? }
		if let Some(ref val) = self.instr_for_dbtr_agt {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "instr_for_dbtr_agt is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "instr_for_dbtr_agt exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.ultmt_dbtr { val.validate()? }
		if let Some(ref val) = self.chrg_br { val.validate()? }
		if let Some(ref val) = self.chrgs_acct { val.validate()? }
		if let Some(ref val) = self.chrgs_acct_agt { val.validate()? }
		for item in &self.cdt_trf_tx_inf { item.validate()? }
		Ok(())
	}
}


// PaymentInstruction44 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentInstruction44 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtInfId") )]
	pub pmt_inf_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtMtd") )]
	pub pmt_mtd: PaymentMethod3Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdAdvcTp", skip_serializing_if = "Option::is_none") )]
	pub reqd_advc_tp: Option<AdviceType1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BtchBookg", skip_serializing_if = "Option::is_none") )]
	pub btch_bookg: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfTxs", skip_serializing_if = "Option::is_none") )]
	pub nb_of_txs: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrlSum", skip_serializing_if = "Option::is_none") )]
	pub ctrl_sum: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtTpInf", skip_serializing_if = "Option::is_none") )]
	pub pmt_tp_inf: Option<PaymentTypeInformation26>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdExctnDt") )]
	pub reqd_exctn_dt: DateAndDateTime2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PoolgAdjstmntDt", skip_serializing_if = "Option::is_none") )]
	pub poolg_adjstmnt_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dbtr") )]
	pub dbtr: PartyIdentification272,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAcct") )]
	pub dbtr_acct: CashAccount40,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgt") )]
	pub dbtr_agt: BranchAndFinancialInstitutionIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrForDbtrAgt", skip_serializing_if = "Option::is_none") )]
	pub instr_for_dbtr_agt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtDbtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_dbtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgBr", skip_serializing_if = "Option::is_none") )]
	pub chrg_br: Option<ChargeBearerType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsAcct", skip_serializing_if = "Option::is_none") )]
	pub chrgs_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsAcctAgt", skip_serializing_if = "Option::is_none") )]
	pub chrgs_acct_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtTrfTxInf") )]
	pub cdt_trf_tx_inf: Vec<CreditTransferTransaction61>,
}

impl PaymentInstruction44 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.pmt_inf_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "pmt_inf_id is shorter than the minimum length of 1".to_string()));
		}
		if self.pmt_inf_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "pmt_inf_id exceeds the maximum length of 35".to_string()));
		}
		self.pmt_mtd.validate()?;
		if let Some(ref val) = self.reqd_advc_tp { val.validate()? }
		if let Some(ref val) = self.nb_of_txs {
			let pattern = Regex::new("[0-9]{1,15}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "nb_of_txs does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.pmt_tp_inf { val.validate()? }
		self.reqd_exctn_dt.validate()?;
		self.dbtr.validate()?;
		self.dbtr_acct.validate()?;
		self.dbtr_agt.validate()?;
		if let Some(ref val) = self.dbtr_agt_acct { val.validate()? }
		if let Some(ref val) = self.instr_for_dbtr_agt {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "instr_for_dbtr_agt is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "instr_for_dbtr_agt exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.ultmt_dbtr { val.validate()? }
		if let Some(ref val) = self.chrg_br { val.validate()? }
		if let Some(ref val) = self.chrgs_acct { val.validate()? }
		if let Some(ref val) = self.chrgs_acct_agt { val.validate()? }
		for item in &self.cdt_trf_tx_inf { item.validate()? }
		Ok(())
	}
}


// PaymentInstruction45 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentInstruction45 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtInfId") )]
	pub pmt_inf_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtMtd") )]
	pub pmt_mtd: PaymentMethod2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdAdvcTp", skip_serializing_if = "Option::is_none") )]
	pub reqd_advc_tp: Option<AdviceType1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BtchBookg", skip_serializing_if = "Option::is_none") )]
	pub btch_bookg: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfTxs", skip_serializing_if = "Option::is_none") )]
	pub nb_of_txs: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrlSum", skip_serializing_if = "Option::is_none") )]
	pub ctrl_sum: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtTpInf", skip_serializing_if = "Option::is_none") )]
	pub pmt_tp_inf: Option<PaymentTypeInformation29>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdColltnDt") )]
	pub reqd_colltn_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cdtr") )]
	pub cdtr: PartyIdentification272,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAcct") )]
	pub cdtr_acct: CashAccount40,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgt") )]
	pub cdtr_agt: BranchAndFinancialInstitutionIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub cdtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtCdtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_cdtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgBr", skip_serializing_if = "Option::is_none") )]
	pub chrg_br: Option<ChargeBearerType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsAcct", skip_serializing_if = "Option::is_none") )]
	pub chrgs_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsAcctAgt", skip_serializing_if = "Option::is_none") )]
	pub chrgs_acct_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrSchmeId", skip_serializing_if = "Option::is_none") )]
	pub cdtr_schme_id: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DrctDbtTxInf") )]
	pub drct_dbt_tx_inf: Vec<DirectDebitTransactionInformation32>,
}

impl PaymentInstruction45 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.pmt_inf_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "pmt_inf_id is shorter than the minimum length of 1".to_string()));
		}
		if self.pmt_inf_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "pmt_inf_id exceeds the maximum length of 35".to_string()));
		}
		self.pmt_mtd.validate()?;
		if let Some(ref val) = self.reqd_advc_tp { val.validate()? }
		if let Some(ref val) = self.nb_of_txs {
			let pattern = Regex::new("[0-9]{1,15}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "nb_of_txs does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.pmt_tp_inf { val.validate()? }
		self.cdtr.validate()?;
		self.cdtr_acct.validate()?;
		self.cdtr_agt.validate()?;
		if let Some(ref val) = self.cdtr_agt_acct { val.validate()? }
		if let Some(ref val) = self.ultmt_cdtr { val.validate()? }
		if let Some(ref val) = self.chrg_br { val.validate()? }
		if let Some(ref val) = self.chrgs_acct { val.validate()? }
		if let Some(ref val) = self.chrgs_acct_agt { val.validate()? }
		if let Some(ref val) = self.cdtr_schme_id { val.validate()? }
		for item in &self.drct_dbt_tx_inf { item.validate()? }
		Ok(())
	}
}


// PaymentInstruction46 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentInstruction46 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtInfId", skip_serializing_if = "Option::is_none") )]
	pub pmt_inf_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtMtd") )]
	pub pmt_mtd: PaymentMethod7Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdAdvcTp", skip_serializing_if = "Option::is_none") )]
	pub reqd_advc_tp: Option<AdviceType1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtTpInf", skip_serializing_if = "Option::is_none") )]
	pub pmt_tp_inf: Option<PaymentTypeInformation29>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdExctnDt", skip_serializing_if = "Option::is_none") )]
	pub reqd_exctn_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XpryDt", skip_serializing_if = "Option::is_none") )]
	pub xpry_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtCond", skip_serializing_if = "Option::is_none") )]
	pub pmt_cond: Option<PaymentCondition2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dbtr") )]
	pub dbtr: PartyIdentification272,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgt") )]
	pub dbtr_agt: BranchAndFinancialInstitutionIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtDbtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_dbtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgBr", skip_serializing_if = "Option::is_none") )]
	pub chrg_br: Option<ChargeBearerType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtTrfTx") )]
	pub cdt_trf_tx: Vec<CreditTransferTransaction65>,
}

impl PaymentInstruction46 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.pmt_inf_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pmt_inf_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "pmt_inf_id exceeds the maximum length of 35".to_string()));
			}
		}
		self.pmt_mtd.validate()?;
		if let Some(ref val) = self.reqd_advc_tp { val.validate()? }
		if let Some(ref val) = self.pmt_tp_inf { val.validate()? }
		if let Some(ref val) = self.reqd_exctn_dt { val.validate()? }
		if let Some(ref val) = self.xpry_dt { val.validate()? }
		if let Some(ref val) = self.pmt_cond { val.validate()? }
		self.dbtr.validate()?;
		if let Some(ref val) = self.dbtr_acct { val.validate()? }
		self.dbtr_agt.validate()?;
		if let Some(ref val) = self.dbtr_agt_acct { val.validate()? }
		if let Some(ref val) = self.ultmt_dbtr { val.validate()? }
		if let Some(ref val) = self.chrg_br { val.validate()? }
		for item in &self.cdt_trf_tx { item.validate()? }
		Ok(())
	}
}


// PaymentInstruction47 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentInstruction47 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId", skip_serializing_if = "Option::is_none") )]
	pub msg_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdExctnDt", skip_serializing_if = "Option::is_none") )]
	pub reqd_exctn_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts", skip_serializing_if = "Option::is_none") )]
	pub sts: Option<Vec<PaymentStatus6>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstdAmt", skip_serializing_if = "Option::is_none") )]
	pub instd_amt: Option<Amount3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBkSttlmAmt", skip_serializing_if = "Option::is_none") )]
	pub intr_bk_sttlm_amt: Option<Amount2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Purp", skip_serializing_if = "Option::is_none") )]
	pub purp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtMtd", skip_serializing_if = "Option::is_none") )]
	pub pmt_mtd: Option<PaymentOrigin1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prty", skip_serializing_if = "Option::is_none") )]
	pub prty: Option<Priority1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrcgVldtyTm", skip_serializing_if = "Option::is_none") )]
	pub prcg_vldty_tm: Option<DateTimePeriod1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrCpy", skip_serializing_if = "Option::is_none") )]
	pub instr_cpy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<PaymentType4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GnrtdOrdr", skip_serializing_if = "Option::is_none") )]
	pub gnrtd_ordr: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxId", skip_serializing_if = "Option::is_none") )]
	pub tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBkSttlmDt", skip_serializing_if = "Option::is_none") )]
	pub intr_bk_sttlm_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndToEndId", skip_serializing_if = "Option::is_none") )]
	pub end_to_end_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pties", skip_serializing_if = "Option::is_none") )]
	pub pties: Option<PaymentTransactionParty4>,
}

impl PaymentInstruction47 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.msg_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.reqd_exctn_dt { val.validate()? }
		if let Some(ref vec) = self.sts { for item in vec { item.validate()? } }
		if let Some(ref val) = self.instd_amt { val.validate()? }
		if let Some(ref val) = self.intr_bk_sttlm_amt { val.validate()? }
		if let Some(ref val) = self.purp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "purp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 10 {
				return Err(ValidationError::new(1002, "purp exceeds the maximum length of 10".to_string()));
			}
		}
		if let Some(ref val) = self.pmt_mtd { val.validate()? }
		if let Some(ref val) = self.prty { val.validate()? }
		if let Some(ref val) = self.prcg_vldty_tm { val.validate()? }
		if let Some(ref val) = self.instr_cpy {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "instr_cpy is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 20000 {
				return Err(ValidationError::new(1002, "instr_cpy exceeds the maximum length of 20000".to_string()));
			}
		}
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.end_to_end_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "end_to_end_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "end_to_end_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.pties { val.validate()? }
		Ok(())
	}
}


// PaymentInstrument16 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentInstrument16 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrdrTp") )]
	pub ordr_tp: FundOrderType5Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrmTp") )]
	pub instrm_tp: FundPaymentType1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<Vec<AdditionalInformation15>>,
}

impl PaymentInstrument16 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.ordr_tp.validate()?;
		self.instrm_tp.validate()?;
		if let Some(ref vec) = self.addtl_inf { for item in vec { item.validate()? } }
		Ok(())
	}
}


// PaymentInstrument17 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentInstrument17 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmCcy") )]
	pub sttlm_ccy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DvddPctg", skip_serializing_if = "Option::is_none") )]
	pub dvdd_pctg: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SbcptPmtInstrm", skip_serializing_if = "Option::is_none") )]
	pub sbcpt_pmt_instrm: Option<PaymentInstrument24Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RedPmtInstrm", skip_serializing_if = "Option::is_none") )]
	pub red_pmt_instrm: Option<PaymentInstrument19Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DvddPmtInstrm", skip_serializing_if = "Option::is_none") )]
	pub dvdd_pmt_instrm: Option<PaymentInstrument19Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SvgsPlanPmtInstrm", skip_serializing_if = "Option::is_none") )]
	pub svgs_plan_pmt_instrm: Option<PaymentInstrument24Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstPmtInstrm", skip_serializing_if = "Option::is_none") )]
	pub intrst_pmt_instrm: Option<PaymentInstrument19Choice>,
}

impl PaymentInstrument17 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.sttlm_ccy) {
			return Err(ValidationError::new(1005, "sttlm_ccy does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.dvdd_pctg {
			if *val < 0.000000 {
				return Err(ValidationError::new(1003, "dvdd_pctg is less than the minimum value of 0.000000".to_string()));
			}
			if *val > 100.000000 {
				return Err(ValidationError::new(1004, "dvdd_pctg exceeds the maximum value of 100.000000".to_string()));
			}
		}
		if let Some(ref val) = self.sbcpt_pmt_instrm { val.validate()? }
		if let Some(ref val) = self.red_pmt_instrm { val.validate()? }
		if let Some(ref val) = self.dvdd_pmt_instrm { val.validate()? }
		if let Some(ref val) = self.svgs_plan_pmt_instrm { val.validate()? }
		if let Some(ref val) = self.intrst_pmt_instrm { val.validate()? }
		Ok(())
	}
}


// PaymentInstrument19Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentInstrument19Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChqDtls", skip_serializing_if = "Option::is_none") )]
	pub chq_dtls: Option<Cheque4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BkrsDrftDtls", skip_serializing_if = "Option::is_none") )]
	pub bkrs_drft_dtls: Option<Cheque4>,
}

impl PaymentInstrument19Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.chq_dtls { val.validate()? }
		if let Some(ref val) = self.bkrs_drft_dtls { val.validate()? }
		Ok(())
	}
}


// PaymentInstrument1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PaymentInstrument1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "BDT") )]
	CodeBDT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BCT") )]
	CodeBCT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CDT") )]
	CodeCDT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CCT") )]
	CodeCCT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CHK") )]
	CodeCHK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BKT") )]
	CodeBKT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DCP") )]
	CodeDCP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CCP") )]
	CodeCCP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RTI") )]
	CodeRTI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CAN") )]
	CodeCAN,
}

impl PaymentInstrument1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PaymentInstrument24Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentInstrument24Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtCardDtls", skip_serializing_if = "Option::is_none") )]
	pub pmt_card_dtls: Option<PaymentCard29>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DrctDbtDtls", skip_serializing_if = "Option::is_none") )]
	pub drct_dbt_dtls: Option<DirectDebitMandate7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Chq", skip_serializing_if = "Option::is_none") )]
	pub chq: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BkrsDrft", skip_serializing_if = "Option::is_none") )]
	pub bkrs_drft: Option<bool>,
}

impl PaymentInstrument24Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.pmt_card_dtls { val.validate()? }
		if let Some(ref val) = self.drct_dbt_dtls { val.validate()? }
		Ok(())
	}
}


// PaymentInstrumentType1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentInstrumentType1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CardNb") )]
	pub card_nb: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AuthrtyReqTp") )]
	pub authrty_req_tp: Vec<AuthorityRequestType1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
}

impl PaymentInstrumentType1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[0-9]{8,28}").unwrap();
		if !pattern.is_match(&self.card_nb) {
			return Err(ValidationError::new(1005, "card_nb does not match the required pattern".to_string()));
		}
		for item in &self.authrty_req_tp { item.validate()? }
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 500 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 500".to_string()));
			}
		}
		Ok(())
	}
}


// PaymentMethod2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PaymentMethod2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "DD") )]
	CodeDD,
}

impl PaymentMethod2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PaymentMethod3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PaymentMethod3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CHK") )]
	CodeCHK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TRF") )]
	CodeTRF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TRA") )]
	CodeTRA,
}

impl PaymentMethod3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PaymentMethod4Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PaymentMethod4Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CHK") )]
	CodeCHK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TRF") )]
	CodeTRF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DD") )]
	CodeDD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TRA") )]
	CodeTRA,
}

impl PaymentMethod4Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PaymentMethod7Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PaymentMethod7Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CHK") )]
	CodeCHK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TRF") )]
	CodeTRF,
}

impl PaymentMethod7Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PaymentOrigin1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentOrigin1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FINMT", skip_serializing_if = "Option::is_none") )]
	pub finmt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XMLMsgNm", skip_serializing_if = "Option::is_none") )]
	pub xml_msg_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Instrm", skip_serializing_if = "Option::is_none") )]
	pub instrm: Option<PaymentInstrument1Code>,
}

impl PaymentOrigin1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.finmt {
			let pattern = Regex::new("[0-9]{1,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "finmt does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.xml_msg_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "xml_msg_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "xml_msg_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.instrm { val.validate()? }
		Ok(())
	}
}


// PaymentReceipt1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PaymentReceipt1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "PAYM") )]
	CodePAYM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RECE") )]
	CodeRECE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NONE") )]
	CodeNONE,
}

impl PaymentReceipt1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PaymentReturnCriteria4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentReturnCriteria4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgIdInd", skip_serializing_if = "Option::is_none") )]
	pub msg_id_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdExctnDtInd", skip_serializing_if = "Option::is_none") )]
	pub reqd_exctn_dt_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrInd", skip_serializing_if = "Option::is_none") )]
	pub instr_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrStsRtrCrit", skip_serializing_if = "Option::is_none") )]
	pub instr_sts_rtr_crit: Option<InstructionStatusReturnCriteria1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstdAmtInd", skip_serializing_if = "Option::is_none") )]
	pub instd_amt_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbtInd", skip_serializing_if = "Option::is_none") )]
	pub cdt_dbt_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBkSttlmAmtInd", skip_serializing_if = "Option::is_none") )]
	pub intr_bk_sttlm_amt_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtyInd", skip_serializing_if = "Option::is_none") )]
	pub prty_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrcgVldtyTmInd", skip_serializing_if = "Option::is_none") )]
	pub prcg_vldty_tm_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PurpInd", skip_serializing_if = "Option::is_none") )]
	pub purp_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrCpyInd", skip_serializing_if = "Option::is_none") )]
	pub instr_cpy_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtMTInd", skip_serializing_if = "Option::is_none") )]
	pub pmt_mt_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtTpInd", skip_serializing_if = "Option::is_none") )]
	pub pmt_tp_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxIdInd", skip_serializing_if = "Option::is_none") )]
	pub tx_id_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBkSttlmDtInd", skip_serializing_if = "Option::is_none") )]
	pub intr_bk_sttlm_dt_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndToEndIdInd", skip_serializing_if = "Option::is_none") )]
	pub end_to_end_id_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtMtdInd", skip_serializing_if = "Option::is_none") )]
	pub pmt_mtd_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrInd", skip_serializing_if = "Option::is_none") )]
	pub dbtr_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgtInd", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstgRmbrsmntAgtInd", skip_serializing_if = "Option::is_none") )]
	pub instg_rmbrsmnt_agt_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstdRmbrsmntAgtInd", skip_serializing_if = "Option::is_none") )]
	pub instd_rmbrsmnt_agt_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyInd", skip_serializing_if = "Option::is_none") )]
	pub intrmy_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgtInd", skip_serializing_if = "Option::is_none") )]
	pub cdtr_agt_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrInd", skip_serializing_if = "Option::is_none") )]
	pub cdtr_ind: Option<bool>,
}

impl PaymentReturnCriteria4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.instr_sts_rtr_crit { val.validate()? }
		Ok(())
	}
}


// PaymentReturnReason7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentReturnReason7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Orgtr", skip_serializing_if = "Option::is_none") )]
	pub orgtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<ReturnReason5Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<Vec<String>>,
}

impl PaymentReturnReason7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgtr { val.validate()? }
		if let Some(ref val) = self.rsn { val.validate()? }
		if let Some(ref vec) = self.addtl_inf {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 105 {
					return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 105".to_string()));
				}
			}
		}
		Ok(())
	}
}


// PaymentReturnReason8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentReturnReason8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlBkTxCd", skip_serializing_if = "Option::is_none") )]
	pub orgnl_bk_tx_cd: Option<BankTransactionCodeStructure4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Orgtr", skip_serializing_if = "Option::is_none") )]
	pub orgtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<ReturnReason5Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<Vec<String>>,
}

impl PaymentReturnReason8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgnl_bk_tx_cd { val.validate()? }
		if let Some(ref val) = self.orgtr { val.validate()? }
		if let Some(ref val) = self.rsn { val.validate()? }
		if let Some(ref vec) = self.addtl_inf {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 105 {
					return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 105".to_string()));
				}
			}
		}
		Ok(())
	}
}


// PaymentReversalReason10 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentReversalReason10 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Orgtr", skip_serializing_if = "Option::is_none") )]
	pub orgtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<ReversalReason4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<Vec<String>>,
}

impl PaymentReversalReason10 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgtr { val.validate()? }
		if let Some(ref val) = self.rsn { val.validate()? }
		if let Some(ref vec) = self.addtl_inf {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 105 {
					return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 105".to_string()));
				}
			}
		}
		Ok(())
	}
}


// PaymentRole1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentRole1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl PaymentRole1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// PaymentRole1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PaymentRole1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "LQMG") )]
	CodeLQMG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LMMG") )]
	CodeLMMG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PYMG") )]
	CodePYMG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REDR") )]
	CodeREDR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BKMG") )]
	CodeBKMG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "STMG") )]
	CodeSTMG,
}

impl PaymentRole1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PaymentSchedule1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentSchedule1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtSchdlId", skip_serializing_if = "Option::is_none") )]
	pub pmt_schdl_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XpctdDt", skip_serializing_if = "Option::is_none") )]
	pub xpctd_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DueDt", skip_serializing_if = "Option::is_none") )]
	pub due_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
}

impl PaymentSchedule1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.pmt_schdl_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pmt_schdl_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "pmt_schdl_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.amt { val.validate()? }
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 1025 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 1025".to_string()));
			}
		}
		Ok(())
	}
}


// PaymentScheduleType2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentScheduleType2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<PaymentScheduleType2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl PaymentScheduleType2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// PaymentScheduleType2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PaymentScheduleType2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CNTR") )]
	CodeCNTR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ESTM") )]
	CodeESTM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BOTH") )]
	CodeBOTH,
}

impl PaymentScheduleType2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PaymentSearch10 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentSearch10 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId", skip_serializing_if = "Option::is_none") )]
	pub msg_id: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdExctnDt", skip_serializing_if = "Option::is_none") )]
	pub reqd_exctn_dt: Option<Vec<DateAndDateTimeSearch3Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtId", skip_serializing_if = "Option::is_none") )]
	pub pmt_id: Option<Vec<PaymentIdentification8Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts", skip_serializing_if = "Option::is_none") )]
	pub sts: Option<Vec<InstructionStatusSearch5>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstdAmt", skip_serializing_if = "Option::is_none") )]
	pub instd_amt: Option<Vec<ActiveOrHistoricAmountRange2Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstdAmtCcy", skip_serializing_if = "Option::is_none") )]
	pub instd_amt_ccy: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbtInd", skip_serializing_if = "Option::is_none") )]
	pub cdt_dbt_ind: Option<CreditDebitCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBkSttlmAmt", skip_serializing_if = "Option::is_none") )]
	pub intr_bk_sttlm_amt: Option<Vec<ActiveAmountRange3Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBkSttlmAmtCcy", skip_serializing_if = "Option::is_none") )]
	pub intr_bk_sttlm_amt_ccy: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtMtd", skip_serializing_if = "Option::is_none") )]
	pub pmt_mtd: Option<Vec<PaymentOrigin1Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtTp", skip_serializing_if = "Option::is_none") )]
	pub pmt_tp: Option<Vec<PaymentType4Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prty", skip_serializing_if = "Option::is_none") )]
	pub prty: Option<Vec<Priority1Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrcgVldtyTm", skip_serializing_if = "Option::is_none") )]
	pub prcg_vldty_tm: Option<Vec<DateTimePeriod1Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Instr", skip_serializing_if = "Option::is_none") )]
	pub instr: Option<Vec<Instruction1Code>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxId", skip_serializing_if = "Option::is_none") )]
	pub tx_id: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UETR", skip_serializing_if = "Option::is_none") )]
	pub uetr: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBkSttlmDt", skip_serializing_if = "Option::is_none") )]
	pub intr_bk_sttlm_dt: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndToEndId", skip_serializing_if = "Option::is_none") )]
	pub end_to_end_id: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pties", skip_serializing_if = "Option::is_none") )]
	pub pties: Option<PaymentTransactionParty4>,
}

impl PaymentSearch10 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.msg_id {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 35 {
					return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
				}
			}
		}
		if let Some(ref vec) = self.reqd_exctn_dt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.pmt_id { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.sts { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.instd_amt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.instd_amt_ccy {
			for item in vec {
				let pattern = Regex::new("[A-Z]{3,3}").unwrap();
				if !pattern.is_match(&item) {
					return Err(ValidationError::new(1005, "instd_amt_ccy does not match the required pattern".to_string()));
				}
			}
		}
		if let Some(ref val) = self.cdt_dbt_ind { val.validate()? }
		if let Some(ref vec) = self.intr_bk_sttlm_amt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.intr_bk_sttlm_amt_ccy {
			for item in vec {
				let pattern = Regex::new("[A-Z]{3,3}").unwrap();
				if !pattern.is_match(&item) {
					return Err(ValidationError::new(1005, "intr_bk_sttlm_amt_ccy does not match the required pattern".to_string()));
				}
			}
		}
		if let Some(ref vec) = self.pmt_mtd { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.pmt_tp { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.prty { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.prcg_vldty_tm { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.instr { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.tx_id {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "tx_id is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 35 {
					return Err(ValidationError::new(1002, "tx_id exceeds the maximum length of 35".to_string()));
				}
			}
		}
		if let Some(ref vec) = self.uetr {
			for item in vec {
				let pattern = Regex::new("[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}").unwrap();
				if !pattern.is_match(&item) {
					return Err(ValidationError::new(1005, "uetr does not match the required pattern".to_string()));
				}
			}
		}
		if let Some(ref vec) = self.end_to_end_id {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "end_to_end_id is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 35 {
					return Err(ValidationError::new(1002, "end_to_end_id exceeds the maximum length of 35".to_string()));
				}
			}
		}
		if let Some(ref val) = self.pties { val.validate()? }
		Ok(())
	}
}


// PaymentStatus6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentStatus6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<PaymentStatusCode6Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtTm", skip_serializing_if = "Option::is_none") )]
	pub dt_tm: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<Vec<PaymentStatusReason1Choice>>,
}

impl PaymentStatus6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.dt_tm { val.validate()? }
		if let Some(ref vec) = self.rsn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// PaymentStatusCode6Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentStatusCode6Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pdg", skip_serializing_if = "Option::is_none") )]
	pub pdg: Option<PendingStatus4Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Fnl", skip_serializing_if = "Option::is_none") )]
	pub fnl: Option<FinalStatus1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RTGS", skip_serializing_if = "Option::is_none") )]
	pub rtgs: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sttlm", skip_serializing_if = "Option::is_none") )]
	pub sttlm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl PaymentStatusCode6Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.pdg { val.validate()? }
		if let Some(ref val) = self.fnl { val.validate()? }
		if let Some(ref val) = self.rtgs {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rtgs is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "rtgs exceeds the maximum length of 4".to_string()));
			}
			let pattern = Regex::new("[a-zA-Z0-9]{1,4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "rtgs does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.sttlm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "sttlm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "sttlm exceeds the maximum length of 4".to_string()));
			}
			let pattern = Regex::new("[a-zA-Z0-9]{1,4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "sttlm does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// PaymentStatusCodeSearch2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentStatusCodeSearch2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PdgSts", skip_serializing_if = "Option::is_none") )]
	pub pdg_sts: Option<PendingStatus4Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FnlSts", skip_serializing_if = "Option::is_none") )]
	pub fnl_sts: Option<FinalStatusCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PdgAndFnlSts", skip_serializing_if = "Option::is_none") )]
	pub pdg_and_fnl_sts: Option<CashPaymentStatus2Code>,
}

impl PaymentStatusCodeSearch2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.pdg_sts { val.validate()? }
		if let Some(ref val) = self.fnl_sts { val.validate()? }
		if let Some(ref val) = self.pdg_and_fnl_sts { val.validate()? }
		Ok(())
	}
}


// PaymentStatusReason1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentStatusReason1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Umtchd", skip_serializing_if = "Option::is_none") )]
	pub umtchd: Option<UnmatchedStatusReason1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Canc", skip_serializing_if = "Option::is_none") )]
	pub canc: Option<CancelledStatusReason1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sspd", skip_serializing_if = "Option::is_none") )]
	pub sspd: Option<SuspendedStatusReason1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PdgFlngSttlm", skip_serializing_if = "Option::is_none") )]
	pub pdg_flng_sttlm: Option<PendingFailingSettlement1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PdgSttlm", skip_serializing_if = "Option::is_none") )]
	pub pdg_sttlm: Option<PendingSettlement2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtryRjctn", skip_serializing_if = "Option::is_none") )]
	pub prtry_rjctn: Option<ProprietaryStatusJustification2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl PaymentStatusReason1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.umtchd { val.validate()? }
		if let Some(ref val) = self.canc { val.validate()? }
		if let Some(ref val) = self.sspd { val.validate()? }
		if let Some(ref val) = self.pdg_flng_sttlm { val.validate()? }
		if let Some(ref val) = self.pdg_sttlm { val.validate()? }
		if let Some(ref val) = self.prtry_rjctn { val.validate()? }
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// PaymentTransaction130 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentTransaction130 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsId", skip_serializing_if = "Option::is_none") )]
	pub sts_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlGrpInf", skip_serializing_if = "Option::is_none") )]
	pub orgnl_grp_inf: Option<OriginalGroupInformation29>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlInstrId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_instr_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlEndToEndId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_end_to_end_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlTxId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlUETR", skip_serializing_if = "Option::is_none") )]
	pub orgnl_uetr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxSts", skip_serializing_if = "Option::is_none") )]
	pub tx_sts: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsRsnInf", skip_serializing_if = "Option::is_none") )]
	pub sts_rsn_inf: Option<Vec<StatusReasonInformation12>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsInf", skip_serializing_if = "Option::is_none") )]
	pub chrgs_inf: Option<Vec<Charges7>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AccptncDtTm", skip_serializing_if = "Option::is_none") )]
	pub accptnc_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FctvIntrBkSttlmDt", skip_serializing_if = "Option::is_none") )]
	pub fctv_intr_bk_sttlm_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcrRef", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrSysRef", skip_serializing_if = "Option::is_none") )]
	pub clr_sys_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstgAgt", skip_serializing_if = "Option::is_none") )]
	pub instg_agt: Option<BranchAndFinancialInstitutionIdentification6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstdAgt", skip_serializing_if = "Option::is_none") )]
	pub instd_agt: Option<BranchAndFinancialInstitutionIdentification6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlTxRef", skip_serializing_if = "Option::is_none") )]
	pub orgnl_tx_ref: Option<OriginalTransactionReference35>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl PaymentTransaction130 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.sts_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "sts_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "sts_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_grp_inf { val.validate()? }
		if let Some(ref val) = self.orgnl_instr_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_instr_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_instr_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_end_to_end_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_end_to_end_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_end_to_end_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_uetr {
			let pattern = Regex::new("[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "orgnl_uetr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.tx_sts {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tx_sts is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "tx_sts exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref vec) = self.sts_rsn_inf { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.chrgs_inf { for item in vec { item.validate()? } }
		if let Some(ref val) = self.fctv_intr_bk_sttlm_dt { val.validate()? }
		if let Some(ref val) = self.acct_svcr_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_svcr_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acct_svcr_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.clr_sys_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "clr_sys_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "clr_sys_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.instg_agt { val.validate()? }
		if let Some(ref val) = self.instd_agt { val.validate()? }
		if let Some(ref val) = self.orgnl_tx_ref { val.validate()? }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// PaymentTransaction149 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentTransaction149 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RvslId", skip_serializing_if = "Option::is_none") )]
	pub rvsl_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlGrpInf", skip_serializing_if = "Option::is_none") )]
	pub orgnl_grp_inf: Option<OriginalGroupInformation29>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlInstrId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_instr_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlEndToEndId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_end_to_end_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlTxId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlUETR", skip_serializing_if = "Option::is_none") )]
	pub orgnl_uetr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlClrSysRef", skip_serializing_if = "Option::is_none") )]
	pub orgnl_clr_sys_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlIntrBkSttlmAmt", skip_serializing_if = "Option::is_none") )]
	pub orgnl_intr_bk_sttlm_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RvsdIntrBkSttlmAmt") )]
	pub rvsd_intr_bk_sttlm_amt: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBkSttlmDt", skip_serializing_if = "Option::is_none") )]
	pub intr_bk_sttlm_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmPrty", skip_serializing_if = "Option::is_none") )]
	pub sttlm_prty: Option<Priority3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmTmIndctn", skip_serializing_if = "Option::is_none") )]
	pub sttlm_tm_indctn: Option<SettlementDateTimeIndication1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RvsdInstdAmt", skip_serializing_if = "Option::is_none") )]
	pub rvsd_instd_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XchgRate", skip_serializing_if = "Option::is_none") )]
	pub xchg_rate: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CompstnAmt", skip_serializing_if = "Option::is_none") )]
	pub compstn_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgBr", skip_serializing_if = "Option::is_none") )]
	pub chrg_br: Option<ChargeBearerType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsInf", skip_serializing_if = "Option::is_none") )]
	pub chrgs_inf: Option<Vec<Charges16>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstgAgt", skip_serializing_if = "Option::is_none") )]
	pub instg_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstdAgt", skip_serializing_if = "Option::is_none") )]
	pub instd_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RvslRsnInf", skip_serializing_if = "Option::is_none") )]
	pub rvsl_rsn_inf: Option<Vec<PaymentReversalReason10>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlTxRef", skip_serializing_if = "Option::is_none") )]
	pub orgnl_tx_ref: Option<OriginalTransactionReference42>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl PaymentTransaction149 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rvsl_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rvsl_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "rvsl_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_grp_inf { val.validate()? }
		if let Some(ref val) = self.orgnl_instr_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_instr_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_instr_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_end_to_end_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_end_to_end_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_end_to_end_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_uetr {
			let pattern = Regex::new("[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "orgnl_uetr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_clr_sys_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_clr_sys_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_clr_sys_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_intr_bk_sttlm_amt { val.validate()? }
		self.rvsd_intr_bk_sttlm_amt.validate()?;
		if let Some(ref val) = self.sttlm_prty { val.validate()? }
		if let Some(ref val) = self.sttlm_tm_indctn { val.validate()? }
		if let Some(ref val) = self.rvsd_instd_amt { val.validate()? }
		if let Some(ref val) = self.compstn_amt { val.validate()? }
		if let Some(ref val) = self.chrg_br { val.validate()? }
		if let Some(ref vec) = self.chrgs_inf { for item in vec { item.validate()? } }
		if let Some(ref val) = self.instg_agt { val.validate()? }
		if let Some(ref val) = self.instd_agt { val.validate()? }
		if let Some(ref vec) = self.rvsl_rsn_inf { for item in vec { item.validate()? } }
		if let Some(ref val) = self.orgnl_tx_ref { val.validate()? }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// PaymentTransaction150 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentTransaction150 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsId", skip_serializing_if = "Option::is_none") )]
	pub sts_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlInstrId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_instr_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlEndToEndId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_end_to_end_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlUETR", skip_serializing_if = "Option::is_none") )]
	pub orgnl_uetr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxSts", skip_serializing_if = "Option::is_none") )]
	pub tx_sts: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsRsnInf", skip_serializing_if = "Option::is_none") )]
	pub sts_rsn_inf: Option<Vec<StatusReasonInformation14>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtCondSts", skip_serializing_if = "Option::is_none") )]
	pub pmt_cond_sts: Option<PaymentConditionStatus2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsInf", skip_serializing_if = "Option::is_none") )]
	pub chrgs_inf: Option<Vec<Charges16>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrDcsnDtTm", skip_serializing_if = "Option::is_none") )]
	pub dbtr_dcsn_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AccptncDtTm", skip_serializing_if = "Option::is_none") )]
	pub accptnc_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcrRef", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrSysRef", skip_serializing_if = "Option::is_none") )]
	pub clr_sys_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlTxRef", skip_serializing_if = "Option::is_none") )]
	pub orgnl_tx_ref: Option<OriginalTransactionReference40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NclsdFile", skip_serializing_if = "Option::is_none") )]
	pub nclsd_file: Option<Vec<Document15>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl PaymentTransaction150 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.sts_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "sts_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "sts_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_instr_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_instr_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_instr_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_end_to_end_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_end_to_end_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_end_to_end_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_uetr {
			let pattern = Regex::new("[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "orgnl_uetr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.tx_sts {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tx_sts is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "tx_sts exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref vec) = self.sts_rsn_inf { for item in vec { item.validate()? } }
		if let Some(ref val) = self.pmt_cond_sts { val.validate()? }
		if let Some(ref vec) = self.chrgs_inf { for item in vec { item.validate()? } }
		if let Some(ref val) = self.acct_svcr_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_svcr_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acct_svcr_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.clr_sys_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "clr_sys_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "clr_sys_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_tx_ref { val.validate()? }
		if let Some(ref vec) = self.nclsd_file { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// PaymentTransaction152 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentTransaction152 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CxlStsId", skip_serializing_if = "Option::is_none") )]
	pub cxl_sts_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RslvdCase", skip_serializing_if = "Option::is_none") )]
	pub rslvd_case: Option<Case6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlGrpInf", skip_serializing_if = "Option::is_none") )]
	pub orgnl_grp_inf: Option<OriginalGroupInformation29>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlInstrId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_instr_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlEndToEndId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_end_to_end_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlTxId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlClrSysRef", skip_serializing_if = "Option::is_none") )]
	pub orgnl_clr_sys_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlUETR", skip_serializing_if = "Option::is_none") )]
	pub orgnl_uetr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxCxlSts", skip_serializing_if = "Option::is_none") )]
	pub tx_cxl_sts: Option<CancellationIndividualStatus1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CxlStsRsnInf", skip_serializing_if = "Option::is_none") )]
	pub cxl_sts_rsn_inf: Option<Vec<CancellationStatusReason5>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RsltnRltdInf", skip_serializing_if = "Option::is_none") )]
	pub rsltn_rltd_inf: Option<ResolutionData5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlIntrBkSttlmAmt", skip_serializing_if = "Option::is_none") )]
	pub orgnl_intr_bk_sttlm_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlIntrBkSttlmDt", skip_serializing_if = "Option::is_none") )]
	pub orgnl_intr_bk_sttlm_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Assgnr", skip_serializing_if = "Option::is_none") )]
	pub assgnr: Option<Party50Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Assgne", skip_serializing_if = "Option::is_none") )]
	pub assgne: Option<Party50Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlTxRef", skip_serializing_if = "Option::is_none") )]
	pub orgnl_tx_ref: Option<OriginalTransactionReference42>,
}

impl PaymentTransaction152 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cxl_sts_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cxl_sts_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "cxl_sts_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.rslvd_case { val.validate()? }
		if let Some(ref val) = self.orgnl_grp_inf { val.validate()? }
		if let Some(ref val) = self.orgnl_instr_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_instr_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_instr_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_end_to_end_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_end_to_end_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_end_to_end_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_clr_sys_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_clr_sys_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_clr_sys_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_uetr {
			let pattern = Regex::new("[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "orgnl_uetr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.tx_cxl_sts { val.validate()? }
		if let Some(ref vec) = self.cxl_sts_rsn_inf { for item in vec { item.validate()? } }
		if let Some(ref val) = self.rsltn_rltd_inf { val.validate()? }
		if let Some(ref val) = self.orgnl_intr_bk_sttlm_amt { val.validate()? }
		if let Some(ref val) = self.assgnr { val.validate()? }
		if let Some(ref val) = self.assgne { val.validate()? }
		if let Some(ref val) = self.orgnl_tx_ref { val.validate()? }
		Ok(())
	}
}


// PaymentTransaction153 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentTransaction153 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CxlStsId", skip_serializing_if = "Option::is_none") )]
	pub cxl_sts_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RslvdCase", skip_serializing_if = "Option::is_none") )]
	pub rslvd_case: Option<Case6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlInstrId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_instr_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlEndToEndId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_end_to_end_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UETR", skip_serializing_if = "Option::is_none") )]
	pub uetr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxCxlSts", skip_serializing_if = "Option::is_none") )]
	pub tx_cxl_sts: Option<CancellationIndividualStatus1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CxlStsRsnInf", skip_serializing_if = "Option::is_none") )]
	pub cxl_sts_rsn_inf: Option<Vec<CancellationStatusReason5>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlInstdAmt", skip_serializing_if = "Option::is_none") )]
	pub orgnl_instd_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlReqdExctnDt", skip_serializing_if = "Option::is_none") )]
	pub orgnl_reqd_exctn_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlReqdColltnDt", skip_serializing_if = "Option::is_none") )]
	pub orgnl_reqd_colltn_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlTxRef", skip_serializing_if = "Option::is_none") )]
	pub orgnl_tx_ref: Option<OriginalTransactionReference42>,
}

impl PaymentTransaction153 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cxl_sts_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cxl_sts_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "cxl_sts_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.rslvd_case { val.validate()? }
		if let Some(ref val) = self.orgnl_instr_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_instr_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_instr_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_end_to_end_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_end_to_end_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_end_to_end_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.uetr {
			let pattern = Regex::new("[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "uetr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.tx_cxl_sts { val.validate()? }
		if let Some(ref vec) = self.cxl_sts_rsn_inf { for item in vec { item.validate()? } }
		if let Some(ref val) = self.orgnl_instd_amt { val.validate()? }
		if let Some(ref val) = self.orgnl_reqd_exctn_dt { val.validate()? }
		if let Some(ref val) = self.orgnl_tx_ref { val.validate()? }
		Ok(())
	}
}


// PaymentTransaction154 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentTransaction154 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CxlId", skip_serializing_if = "Option::is_none") )]
	pub cxl_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Case", skip_serializing_if = "Option::is_none") )]
	pub case: Option<Case6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlInstrId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_instr_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlEndToEndId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_end_to_end_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlUETR", skip_serializing_if = "Option::is_none") )]
	pub orgnl_uetr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlInstdAmt", skip_serializing_if = "Option::is_none") )]
	pub orgnl_instd_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlReqdExctnDt", skip_serializing_if = "Option::is_none") )]
	pub orgnl_reqd_exctn_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlReqdColltnDt", skip_serializing_if = "Option::is_none") )]
	pub orgnl_reqd_colltn_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CxlRsnInf", skip_serializing_if = "Option::is_none") )]
	pub cxl_rsn_inf: Option<Vec<PaymentCancellationReason6>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlTxRef", skip_serializing_if = "Option::is_none") )]
	pub orgnl_tx_ref: Option<OriginalTransactionReference42>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl PaymentTransaction154 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cxl_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cxl_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "cxl_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.case { val.validate()? }
		if let Some(ref val) = self.orgnl_instr_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_instr_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_instr_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_end_to_end_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_end_to_end_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_end_to_end_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_uetr {
			let pattern = Regex::new("[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "orgnl_uetr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_instd_amt { val.validate()? }
		if let Some(ref val) = self.orgnl_reqd_exctn_dt { val.validate()? }
		if let Some(ref vec) = self.cxl_rsn_inf { for item in vec { item.validate()? } }
		if let Some(ref val) = self.orgnl_tx_ref { val.validate()? }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// PaymentTransaction155 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentTransaction155 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CxlId", skip_serializing_if = "Option::is_none") )]
	pub cxl_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Case", skip_serializing_if = "Option::is_none") )]
	pub case: Option<Case6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlGrpInf", skip_serializing_if = "Option::is_none") )]
	pub orgnl_grp_inf: Option<OriginalGroupInformation29>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlInstrId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_instr_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlEndToEndId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_end_to_end_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlTxId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlUETR", skip_serializing_if = "Option::is_none") )]
	pub orgnl_uetr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlClrSysRef", skip_serializing_if = "Option::is_none") )]
	pub orgnl_clr_sys_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlIntrBkSttlmAmt", skip_serializing_if = "Option::is_none") )]
	pub orgnl_intr_bk_sttlm_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlIntrBkSttlmDt", skip_serializing_if = "Option::is_none") )]
	pub orgnl_intr_bk_sttlm_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Assgnr", skip_serializing_if = "Option::is_none") )]
	pub assgnr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Assgne", skip_serializing_if = "Option::is_none") )]
	pub assgne: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CxlRsnInf", skip_serializing_if = "Option::is_none") )]
	pub cxl_rsn_inf: Option<Vec<PaymentCancellationReason6>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlTxRef", skip_serializing_if = "Option::is_none") )]
	pub orgnl_tx_ref: Option<OriginalTransactionReference42>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl PaymentTransaction155 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cxl_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cxl_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "cxl_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.case { val.validate()? }
		if let Some(ref val) = self.orgnl_grp_inf { val.validate()? }
		if let Some(ref val) = self.orgnl_instr_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_instr_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_instr_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_end_to_end_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_end_to_end_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_end_to_end_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_uetr {
			let pattern = Regex::new("[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "orgnl_uetr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_clr_sys_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_clr_sys_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_clr_sys_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_intr_bk_sttlm_amt { val.validate()? }
		if let Some(ref val) = self.assgnr { val.validate()? }
		if let Some(ref val) = self.assgne { val.validate()? }
		if let Some(ref vec) = self.cxl_rsn_inf { for item in vec { item.validate()? } }
		if let Some(ref val) = self.orgnl_tx_ref { val.validate()? }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// PaymentTransaction156 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentTransaction156 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RvslId", skip_serializing_if = "Option::is_none") )]
	pub rvsl_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlInstrId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_instr_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlEndToEndId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_end_to_end_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlUETR", skip_serializing_if = "Option::is_none") )]
	pub orgnl_uetr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlInstdAmt", skip_serializing_if = "Option::is_none") )]
	pub orgnl_instd_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RvsdInstdAmt", skip_serializing_if = "Option::is_none") )]
	pub rvsd_instd_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgBr", skip_serializing_if = "Option::is_none") )]
	pub chrg_br: Option<ChargeBearerType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RvslRsnInf", skip_serializing_if = "Option::is_none") )]
	pub rvsl_rsn_inf: Option<Vec<PaymentReversalReason10>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlTxRef", skip_serializing_if = "Option::is_none") )]
	pub orgnl_tx_ref: Option<OriginalTransactionReference42>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl PaymentTransaction156 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rvsl_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rvsl_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "rvsl_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_instr_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_instr_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_instr_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_end_to_end_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_end_to_end_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_end_to_end_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_uetr {
			let pattern = Regex::new("[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "orgnl_uetr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_instd_amt { val.validate()? }
		if let Some(ref val) = self.rvsd_instd_amt { val.validate()? }
		if let Some(ref val) = self.chrg_br { val.validate()? }
		if let Some(ref vec) = self.rvsl_rsn_inf { for item in vec { item.validate()? } }
		if let Some(ref val) = self.orgnl_tx_ref { val.validate()? }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// PaymentTransaction157 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentTransaction157 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModStsId", skip_serializing_if = "Option::is_none") )]
	pub mod_sts_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RslvdCase", skip_serializing_if = "Option::is_none") )]
	pub rslvd_case: Option<Case6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlGrpInf") )]
	pub orgnl_grp_inf: OriginalGroupInformation29,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlPmtInfId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_pmt_inf_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlInstrId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_instr_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlEndToEndId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_end_to_end_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlTxId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlClrSysRef", skip_serializing_if = "Option::is_none") )]
	pub orgnl_clr_sys_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlUETR", skip_serializing_if = "Option::is_none") )]
	pub orgnl_uetr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModStsRsnInf", skip_serializing_if = "Option::is_none") )]
	pub mod_sts_rsn_inf: Option<Vec<ModificationStatusReason3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RsltnRltdInf", skip_serializing_if = "Option::is_none") )]
	pub rsltn_rltd_inf: Option<ResolutionData5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlIntrBkSttlmAmt", skip_serializing_if = "Option::is_none") )]
	pub orgnl_intr_bk_sttlm_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlIntrBkSttlmDt", skip_serializing_if = "Option::is_none") )]
	pub orgnl_intr_bk_sttlm_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Assgnr", skip_serializing_if = "Option::is_none") )]
	pub assgnr: Option<Party50Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Assgne", skip_serializing_if = "Option::is_none") )]
	pub assgne: Option<Party50Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlTxRef", skip_serializing_if = "Option::is_none") )]
	pub orgnl_tx_ref: Option<OriginalTransactionReference42>,
}

impl PaymentTransaction157 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mod_sts_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mod_sts_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "mod_sts_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.rslvd_case { val.validate()? }
		self.orgnl_grp_inf.validate()?;
		if let Some(ref val) = self.orgnl_pmt_inf_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_pmt_inf_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_pmt_inf_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_instr_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_instr_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_instr_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_end_to_end_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_end_to_end_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_end_to_end_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_clr_sys_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_clr_sys_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_clr_sys_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_uetr {
			let pattern = Regex::new("[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "orgnl_uetr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref vec) = self.mod_sts_rsn_inf { for item in vec { item.validate()? } }
		if let Some(ref val) = self.rsltn_rltd_inf { val.validate()? }
		if let Some(ref val) = self.orgnl_intr_bk_sttlm_amt { val.validate()? }
		if let Some(ref val) = self.assgnr { val.validate()? }
		if let Some(ref val) = self.assgne { val.validate()? }
		if let Some(ref val) = self.orgnl_tx_ref { val.validate()? }
		Ok(())
	}
}


// PaymentTransaction158 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentTransaction158 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsReqId", skip_serializing_if = "Option::is_none") )]
	pub sts_req_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlGrpInf", skip_serializing_if = "Option::is_none") )]
	pub orgnl_grp_inf: Option<OriginalGroupInformation29>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlInstrId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_instr_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlEndToEndId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_end_to_end_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlTxId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlUETR", skip_serializing_if = "Option::is_none") )]
	pub orgnl_uetr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AccptncDtTm", skip_serializing_if = "Option::is_none") )]
	pub accptnc_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrSysRef", skip_serializing_if = "Option::is_none") )]
	pub clr_sys_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstgAgt", skip_serializing_if = "Option::is_none") )]
	pub instg_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstdAgt", skip_serializing_if = "Option::is_none") )]
	pub instd_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlTxRef", skip_serializing_if = "Option::is_none") )]
	pub orgnl_tx_ref: Option<OriginalTransactionReference42>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl PaymentTransaction158 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.sts_req_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "sts_req_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "sts_req_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_grp_inf { val.validate()? }
		if let Some(ref val) = self.orgnl_instr_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_instr_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_instr_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_end_to_end_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_end_to_end_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_end_to_end_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_uetr {
			let pattern = Regex::new("[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "orgnl_uetr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.clr_sys_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "clr_sys_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "clr_sys_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.instg_agt { val.validate()? }
		if let Some(ref val) = self.instd_agt { val.validate()? }
		if let Some(ref val) = self.orgnl_tx_ref { val.validate()? }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// PaymentTransaction159 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentTransaction159 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RtrId", skip_serializing_if = "Option::is_none") )]
	pub rtr_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlGrpInf", skip_serializing_if = "Option::is_none") )]
	pub orgnl_grp_inf: Option<OriginalGroupInformation29>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlInstrId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_instr_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlEndToEndId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_end_to_end_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlTxId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlUETR", skip_serializing_if = "Option::is_none") )]
	pub orgnl_uetr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlClrSysRef", skip_serializing_if = "Option::is_none") )]
	pub orgnl_clr_sys_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlIntrBkSttlmAmt", skip_serializing_if = "Option::is_none") )]
	pub orgnl_intr_bk_sttlm_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlIntrBkSttlmDt", skip_serializing_if = "Option::is_none") )]
	pub orgnl_intr_bk_sttlm_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtTpInf", skip_serializing_if = "Option::is_none") )]
	pub pmt_tp_inf: Option<PaymentTypeInformation28>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RtrdIntrBkSttlmAmt") )]
	pub rtrd_intr_bk_sttlm_amt: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBkSttlmDt", skip_serializing_if = "Option::is_none") )]
	pub intr_bk_sttlm_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmPrty", skip_serializing_if = "Option::is_none") )]
	pub sttlm_prty: Option<Priority3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmTmIndctn", skip_serializing_if = "Option::is_none") )]
	pub sttlm_tm_indctn: Option<SettlementDateTimeIndication1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmTmReq", skip_serializing_if = "Option::is_none") )]
	pub sttlm_tm_req: Option<SettlementTimeRequest2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RtrdInstdAmt", skip_serializing_if = "Option::is_none") )]
	pub rtrd_instd_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XchgRate", skip_serializing_if = "Option::is_none") )]
	pub xchg_rate: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CompstnAmt", skip_serializing_if = "Option::is_none") )]
	pub compstn_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgBr", skip_serializing_if = "Option::is_none") )]
	pub chrg_br: Option<ChargeBearerType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsInf", skip_serializing_if = "Option::is_none") )]
	pub chrgs_inf: Option<Vec<Charges16>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrSysRef", skip_serializing_if = "Option::is_none") )]
	pub clr_sys_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstgAgt", skip_serializing_if = "Option::is_none") )]
	pub instg_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstdAgt", skip_serializing_if = "Option::is_none") )]
	pub instd_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RtrChain", skip_serializing_if = "Option::is_none") )]
	pub rtr_chain: Option<TransactionParties11>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RtrRsnInf", skip_serializing_if = "Option::is_none") )]
	pub rtr_rsn_inf: Option<Vec<PaymentReturnReason7>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlTxRef", skip_serializing_if = "Option::is_none") )]
	pub orgnl_tx_ref: Option<OriginalTransactionReference41>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl PaymentTransaction159 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rtr_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rtr_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "rtr_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_grp_inf { val.validate()? }
		if let Some(ref val) = self.orgnl_instr_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_instr_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_instr_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_end_to_end_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_end_to_end_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_end_to_end_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_uetr {
			let pattern = Regex::new("[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "orgnl_uetr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_clr_sys_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_clr_sys_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_clr_sys_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_intr_bk_sttlm_amt { val.validate()? }
		if let Some(ref val) = self.pmt_tp_inf { val.validate()? }
		self.rtrd_intr_bk_sttlm_amt.validate()?;
		if let Some(ref val) = self.sttlm_prty { val.validate()? }
		if let Some(ref val) = self.sttlm_tm_indctn { val.validate()? }
		if let Some(ref val) = self.sttlm_tm_req { val.validate()? }
		if let Some(ref val) = self.rtrd_instd_amt { val.validate()? }
		if let Some(ref val) = self.compstn_amt { val.validate()? }
		if let Some(ref val) = self.chrg_br { val.validate()? }
		if let Some(ref vec) = self.chrgs_inf { for item in vec { item.validate()? } }
		if let Some(ref val) = self.clr_sys_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "clr_sys_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "clr_sys_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.instg_agt { val.validate()? }
		if let Some(ref val) = self.instd_agt { val.validate()? }
		if let Some(ref val) = self.rtr_chain { val.validate()? }
		if let Some(ref vec) = self.rtr_rsn_inf { for item in vec { item.validate()? } }
		if let Some(ref val) = self.orgnl_tx_ref { val.validate()? }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// PaymentTransaction160 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentTransaction160 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsId", skip_serializing_if = "Option::is_none") )]
	pub sts_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlInstrId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_instr_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlEndToEndId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_end_to_end_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlUETR", skip_serializing_if = "Option::is_none") )]
	pub orgnl_uetr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxSts", skip_serializing_if = "Option::is_none") )]
	pub tx_sts: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsRsnInf", skip_serializing_if = "Option::is_none") )]
	pub sts_rsn_inf: Option<Vec<StatusReasonInformation14>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsInf", skip_serializing_if = "Option::is_none") )]
	pub chrgs_inf: Option<Vec<Charges16>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrckrData", skip_serializing_if = "Option::is_none") )]
	pub trckr_data: Option<TrackerData7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AccptncDtTm", skip_serializing_if = "Option::is_none") )]
	pub accptnc_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcrRef", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrSysRef", skip_serializing_if = "Option::is_none") )]
	pub clr_sys_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlTxRef", skip_serializing_if = "Option::is_none") )]
	pub orgnl_tx_ref: Option<OriginalTransactionReference42>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl PaymentTransaction160 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.sts_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "sts_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "sts_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_instr_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_instr_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_instr_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_end_to_end_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_end_to_end_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_end_to_end_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_uetr {
			let pattern = Regex::new("[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "orgnl_uetr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.tx_sts {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tx_sts is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "tx_sts exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref vec) = self.sts_rsn_inf { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.chrgs_inf { for item in vec { item.validate()? } }
		if let Some(ref val) = self.trckr_data { val.validate()? }
		if let Some(ref val) = self.acct_svcr_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_svcr_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acct_svcr_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.clr_sys_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "clr_sys_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "clr_sys_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_tx_ref { val.validate()? }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// PaymentTransaction161 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentTransaction161 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsId", skip_serializing_if = "Option::is_none") )]
	pub sts_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlGrpInf", skip_serializing_if = "Option::is_none") )]
	pub orgnl_grp_inf: Option<OriginalGroupInformation29>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlInstrId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_instr_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlEndToEndId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_end_to_end_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlTxId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlUETR", skip_serializing_if = "Option::is_none") )]
	pub orgnl_uetr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxSts", skip_serializing_if = "Option::is_none") )]
	pub tx_sts: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsRsnInf", skip_serializing_if = "Option::is_none") )]
	pub sts_rsn_inf: Option<Vec<StatusReasonInformation14>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsInf", skip_serializing_if = "Option::is_none") )]
	pub chrgs_inf: Option<Vec<Charges16>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AccptncDtTm", skip_serializing_if = "Option::is_none") )]
	pub accptnc_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrcgDt", skip_serializing_if = "Option::is_none") )]
	pub prcg_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FctvIntrBkSttlmDt", skip_serializing_if = "Option::is_none") )]
	pub fctv_intr_bk_sttlm_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcrRef", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrSysRef", skip_serializing_if = "Option::is_none") )]
	pub clr_sys_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstgAgt", skip_serializing_if = "Option::is_none") )]
	pub instg_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstdAgt", skip_serializing_if = "Option::is_none") )]
	pub instd_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlTxRef", skip_serializing_if = "Option::is_none") )]
	pub orgnl_tx_ref: Option<OriginalTransactionReference42>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl PaymentTransaction161 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.sts_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "sts_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "sts_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_grp_inf { val.validate()? }
		if let Some(ref val) = self.orgnl_instr_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_instr_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_instr_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_end_to_end_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_end_to_end_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_end_to_end_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_uetr {
			let pattern = Regex::new("[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "orgnl_uetr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.tx_sts {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tx_sts is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "tx_sts exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref vec) = self.sts_rsn_inf { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.chrgs_inf { for item in vec { item.validate()? } }
		if let Some(ref val) = self.prcg_dt { val.validate()? }
		if let Some(ref val) = self.fctv_intr_bk_sttlm_dt { val.validate()? }
		if let Some(ref val) = self.acct_svcr_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_svcr_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acct_svcr_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.clr_sys_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "clr_sys_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "clr_sys_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.instg_agt { val.validate()? }
		if let Some(ref val) = self.instd_agt { val.validate()? }
		if let Some(ref val) = self.orgnl_tx_ref { val.validate()? }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// PaymentTransactionParty4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentTransactionParty4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstgAgt", skip_serializing_if = "Option::is_none") )]
	pub instg_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstdAgt", skip_serializing_if = "Option::is_none") )]
	pub instd_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtDbtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_dbtr: Option<Party50Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dbtr", skip_serializing_if = "Option::is_none") )]
	pub dbtr: Option<Party50Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgt", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstgRmbrsmntAgt", skip_serializing_if = "Option::is_none") )]
	pub instg_rmbrsmnt_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstdRmbrsmntAgt", skip_serializing_if = "Option::is_none") )]
	pub instd_rmbrsmnt_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt1", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt1: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt2", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt2: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt3", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt3: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgt", skip_serializing_if = "Option::is_none") )]
	pub cdtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cdtr", skip_serializing_if = "Option::is_none") )]
	pub cdtr: Option<Party50Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtCdtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_cdtr: Option<Party50Choice>,
}

impl PaymentTransactionParty4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.instg_agt { val.validate()? }
		if let Some(ref val) = self.instd_agt { val.validate()? }
		if let Some(ref val) = self.ultmt_dbtr { val.validate()? }
		if let Some(ref val) = self.dbtr { val.validate()? }
		if let Some(ref val) = self.dbtr_agt { val.validate()? }
		if let Some(ref val) = self.instg_rmbrsmnt_agt { val.validate()? }
		if let Some(ref val) = self.instd_rmbrsmnt_agt { val.validate()? }
		if let Some(ref val) = self.intrmy_agt1 { val.validate()? }
		if let Some(ref val) = self.intrmy_agt2 { val.validate()? }
		if let Some(ref val) = self.intrmy_agt3 { val.validate()? }
		if let Some(ref val) = self.cdtr_agt { val.validate()? }
		if let Some(ref val) = self.cdtr { val.validate()? }
		if let Some(ref val) = self.ultmt_cdtr { val.validate()? }
		Ok(())
	}
}


// PaymentTransactionStatus1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentTransactionStatus1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts") )]
	pub sts: TransactionStatus1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsRsnInf", skip_serializing_if = "Option::is_none") )]
	pub sts_rsn_inf: Option<Vec<StatusReasonInformation12>>,
}

impl PaymentTransactionStatus1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.sts.validate()?;
		if let Some(ref vec) = self.sts_rsn_inf { for item in vec { item.validate()? } }
		Ok(())
	}
}


// PaymentType3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PaymentType3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CBS") )]
	CodeCBS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BCK") )]
	CodeBCK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BAL") )]
	CodeBAL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CLS") )]
	CodeCLS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CTR") )]
	CodeCTR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CBH") )]
	CodeCBH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CBP") )]
	CodeCBP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DPG") )]
	CodeDPG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DPN") )]
	CodeDPN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EXP") )]
	CodeEXP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TCH") )]
	CodeTCH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LMT") )]
	CodeLMT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LIQ") )]
	CodeLIQ,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DPP") )]
	CodeDPP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DPH") )]
	CodeDPH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DPS") )]
	CodeDPS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "STF") )]
	CodeSTF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TRP") )]
	CodeTRP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TCS") )]
	CodeTCS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LOA") )]
	CodeLOA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LOR") )]
	CodeLOR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TCP") )]
	CodeTCP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OND") )]
	CodeOND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MGL") )]
	CodeMGL,
}

impl PaymentType3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PaymentType4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentType4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<PaymentType3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl PaymentType4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// PaymentType4Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PaymentType4Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "UFRO") )]
	CodeUFRO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UWIN") )]
	CodeUWIN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PEXH") )]
	CodePEXH,
}

impl PaymentType4Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PaymentType5Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentType5Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<PaymentType4Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtryTp", skip_serializing_if = "Option::is_none") )]
	pub prtry_tp: Option<String>,
}

impl PaymentType5Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.prtry_tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry_tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "prtry_tp exceeds the maximum length of 4".to_string()));
			}
			let pattern = Regex::new("[a-zA-Z0-9]{1,4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "prtry_tp does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// PaymentTypeInformation26 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentTypeInformation26 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrPrty", skip_serializing_if = "Option::is_none") )]
	pub instr_prty: Option<Priority2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SvcLvl", skip_serializing_if = "Option::is_none") )]
	pub svc_lvl: Option<Vec<ServiceLevel8Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LclInstrm", skip_serializing_if = "Option::is_none") )]
	pub lcl_instrm: Option<LocalInstrument2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtgyPurp", skip_serializing_if = "Option::is_none") )]
	pub ctgy_purp: Option<CategoryPurpose1Choice>,
}

impl PaymentTypeInformation26 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.instr_prty { val.validate()? }
		if let Some(ref vec) = self.svc_lvl { for item in vec { item.validate()? } }
		if let Some(ref val) = self.lcl_instrm { val.validate()? }
		if let Some(ref val) = self.ctgy_purp { val.validate()? }
		Ok(())
	}
}


// PaymentTypeInformation27 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentTypeInformation27 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrPrty", skip_serializing_if = "Option::is_none") )]
	pub instr_prty: Option<Priority2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrChanl", skip_serializing_if = "Option::is_none") )]
	pub clr_chanl: Option<ClearingChannel2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SvcLvl", skip_serializing_if = "Option::is_none") )]
	pub svc_lvl: Option<Vec<ServiceLevel8Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LclInstrm", skip_serializing_if = "Option::is_none") )]
	pub lcl_instrm: Option<LocalInstrument2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SeqTp", skip_serializing_if = "Option::is_none") )]
	pub seq_tp: Option<SequenceType3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtgyPurp", skip_serializing_if = "Option::is_none") )]
	pub ctgy_purp: Option<CategoryPurpose1Choice>,
}

impl PaymentTypeInformation27 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.instr_prty { val.validate()? }
		if let Some(ref val) = self.clr_chanl { val.validate()? }
		if let Some(ref vec) = self.svc_lvl { for item in vec { item.validate()? } }
		if let Some(ref val) = self.lcl_instrm { val.validate()? }
		if let Some(ref val) = self.seq_tp { val.validate()? }
		if let Some(ref val) = self.ctgy_purp { val.validate()? }
		Ok(())
	}
}


// PaymentTypeInformation28 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentTypeInformation28 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrPrty", skip_serializing_if = "Option::is_none") )]
	pub instr_prty: Option<Priority2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrChanl", skip_serializing_if = "Option::is_none") )]
	pub clr_chanl: Option<ClearingChannel2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SvcLvl", skip_serializing_if = "Option::is_none") )]
	pub svc_lvl: Option<Vec<ServiceLevel8Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LclInstrm", skip_serializing_if = "Option::is_none") )]
	pub lcl_instrm: Option<LocalInstrument2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtgyPurp", skip_serializing_if = "Option::is_none") )]
	pub ctgy_purp: Option<CategoryPurpose1Choice>,
}

impl PaymentTypeInformation28 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.instr_prty { val.validate()? }
		if let Some(ref val) = self.clr_chanl { val.validate()? }
		if let Some(ref vec) = self.svc_lvl { for item in vec { item.validate()? } }
		if let Some(ref val) = self.lcl_instrm { val.validate()? }
		if let Some(ref val) = self.ctgy_purp { val.validate()? }
		Ok(())
	}
}


// PaymentTypeInformation29 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PaymentTypeInformation29 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrPrty", skip_serializing_if = "Option::is_none") )]
	pub instr_prty: Option<Priority2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SvcLvl", skip_serializing_if = "Option::is_none") )]
	pub svc_lvl: Option<Vec<ServiceLevel8Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LclInstrm", skip_serializing_if = "Option::is_none") )]
	pub lcl_instrm: Option<LocalInstrument2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SeqTp", skip_serializing_if = "Option::is_none") )]
	pub seq_tp: Option<SequenceType3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtgyPurp", skip_serializing_if = "Option::is_none") )]
	pub ctgy_purp: Option<CategoryPurpose1Choice>,
}

impl PaymentTypeInformation29 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.instr_prty { val.validate()? }
		if let Some(ref vec) = self.svc_lvl { for item in vec { item.validate()? } }
		if let Some(ref val) = self.lcl_instrm { val.validate()? }
		if let Some(ref val) = self.seq_tp { val.validate()? }
		if let Some(ref val) = self.ctgy_purp { val.validate()? }
		Ok(())
	}
}


// PendingFailingSettlement1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PendingFailingSettlement1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "AWMO") )]
	CodeAWMO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AWSH") )]
	CodeAWSH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LAAW") )]
	CodeLAAW,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DOCY") )]
	CodeDOCY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CLAT") )]
	CodeCLAT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CERT") )]
	CodeCERT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MINO") )]
	CodeMINO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PHSE") )]
	CodePHSE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SBLO") )]
	CodeSBLO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DKNY") )]
	CodeDKNY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "STCD") )]
	CodeSTCD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BENO") )]
	CodeBENO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LACK") )]
	CodeLACK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LATE") )]
	CodeLATE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CANR") )]
	CodeCANR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MLAT") )]
	CodeMLAT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OBJT") )]
	CodeOBJT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DOCC") )]
	CodeDOCC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BLOC") )]
	CodeBLOC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CHAS") )]
	CodeCHAS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NEWI") )]
	CodeNEWI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CLAC") )]
	CodeCLAC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PART") )]
	CodePART,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CMON") )]
	CodeCMON,
	#[cfg_attr( feature = "derive_serde", serde(rename = "COLL") )]
	CodeCOLL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DEPO") )]
	CodeDEPO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FLIM") )]
	CodeFLIM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NOFX") )]
	CodeNOFX,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INCA") )]
	CodeINCA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LINK") )]
	CodeLINK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BYIY") )]
	CodeBYIY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CAIS") )]
	CodeCAIS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LALO") )]
	CodeLALO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MONY") )]
	CodeMONY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NCON") )]
	CodeNCON,
	#[cfg_attr( feature = "derive_serde", serde(rename = "YCOL") )]
	CodeYCOL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REFS") )]
	CodeREFS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SDUT") )]
	CodeSDUT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CYCL") )]
	CodeCYCL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BATC") )]
	CodeBATC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GUAD") )]
	CodeGUAD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PREA") )]
	CodePREA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GLOB") )]
	CodeGLOB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CPEC") )]
	CodeCPEC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MUNO") )]
	CodeMUNO,
}

impl PendingFailingSettlement1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PendingOpeningStatusReason1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PendingOpeningStatusReason1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd") )]
	pub cd: PendingOpeningStatusReason2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
}

impl PendingOpeningStatusReason1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.cd.validate()?;
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 350".to_string()));
			}
		}
		Ok(())
	}
}


// PendingOpeningStatusReason1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PendingOpeningStatusReason1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NoSpcfdRsn", skip_serializing_if = "Option::is_none") )]
	pub no_spcfd_rsn: Option<NoReasonCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<Vec<PendingOpeningStatusReason1>>,
}

impl PendingOpeningStatusReason1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.no_spcfd_rsn { val.validate()? }
		if let Some(ref vec) = self.rsn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// PendingOpeningStatusReason1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PendingOpeningStatusReason1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ATHR") )]
	CodeATHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ATHP") )]
	CodeATHP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FRDM") )]
	CodeFRDM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "KYCM") )]
	CodeKYCM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NOTO") )]
	CodeNOTO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REST") )]
	CodeREST,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RIGH") )]
	CodeRIGH,
}

impl PendingOpeningStatusReason1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PendingOpeningStatusReason2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PendingOpeningStatusReason2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<PendingOpeningStatusReason1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification36>,
}

impl PendingOpeningStatusReason2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// PendingProcessingReason8Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PendingProcessingReason8Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification36>,
}

impl PendingProcessingReason8Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// PendingProcessingReason9Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PendingProcessingReason9Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NoSpcfdRsn", skip_serializing_if = "Option::is_none") )]
	pub no_spcfd_rsn: Option<NoReasonCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<Vec<PendingProcessingReason8Choice>>,
}

impl PendingProcessingReason9Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.no_spcfd_rsn { val.validate()? }
		if let Some(ref vec) = self.rsn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// PendingProcessingStatusReason1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PendingProcessingStatusReason1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn") )]
	pub rsn: PendingProcessingReason9Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlRsnInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_rsn_inf: Option<String>,
}

impl PendingProcessingStatusReason1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.rsn.validate()?;
		if let Some(ref val) = self.addtl_rsn_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_rsn_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 210 {
				return Err(ValidationError::new(1002, "addtl_rsn_inf exceeds the maximum length of 210".to_string()));
			}
		}
		Ok(())
	}
}


// PendingReason10Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PendingReason10Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "AWMO") )]
	CodeAWMO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ADEA") )]
	CodeADEA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CAIS") )]
	CodeCAIS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REFU") )]
	CodeREFU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AWSH") )]
	CodeAWSH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PHSE") )]
	CodePHSE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TAMM") )]
	CodeTAMM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DOCY") )]
	CodeDOCY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DOCC") )]
	CodeDOCC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BLOC") )]
	CodeBLOC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CHAS") )]
	CodeCHAS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NEWI") )]
	CodeNEWI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CLAC") )]
	CodeCLAC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MUNO") )]
	CodeMUNO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GLOB") )]
	CodeGLOB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PREA") )]
	CodePREA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PART") )]
	CodePART,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NMAS") )]
	CodeNMAS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NOFX") )]
	CodeNOFX,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CMON") )]
	CodeCMON,
	#[cfg_attr( feature = "derive_serde", serde(rename = "YCOL") )]
	CodeYCOL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "COLL") )]
	CodeCOLL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DEPO") )]
	CodeDEPO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FLIM") )]
	CodeFLIM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INCA") )]
	CodeINCA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LINK") )]
	CodeLINK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FUTU") )]
	CodeFUTU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LACK") )]
	CodeLACK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LALO") )]
	CodeLALO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MONY") )]
	CodeMONY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NCON") )]
	CodeNCON,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REFS") )]
	CodeREFS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SDUT") )]
	CodeSDUT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BATC") )]
	CodeBATC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CYCL") )]
	CodeCYCL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SBLO") )]
	CodeSBLO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CPEC") )]
	CodeCPEC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MINO") )]
	CodeMINO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IAAD") )]
	CodeIAAD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PHCK") )]
	CodePHCK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BENO") )]
	CodeBENO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BOTH") )]
	CodeBOTH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CLHT") )]
	CodeCLHT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DENO") )]
	CodeDENO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DISA") )]
	CodeDISA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DKNY") )]
	CodeDKNY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FROZ") )]
	CodeFROZ,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LAAW") )]
	CodeLAAW,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LATE") )]
	CodeLATE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LIQU") )]
	CodeLIQU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRCY") )]
	CodePRCY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REGT") )]
	CodeREGT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SETS") )]
	CodeSETS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CERT") )]
	CodeCERT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRSY") )]
	CodePRSY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INBC") )]
	CodeINBC,
}

impl PendingReason10Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PendingReason14 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PendingReason14 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd") )]
	pub cd: PendingReason26Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlRsnInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_rsn_inf: Option<String>,
}

impl PendingReason14 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.cd.validate()?;
		if let Some(ref val) = self.addtl_rsn_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_rsn_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 210 {
				return Err(ValidationError::new(1002, "addtl_rsn_inf exceeds the maximum length of 210".to_string()));
			}
		}
		Ok(())
	}
}


// PendingReason16 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PendingReason16 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd") )]
	pub cd: PendingReason28Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlRsnInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_rsn_inf: Option<String>,
}

impl PendingReason16 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.cd.validate()?;
		if let Some(ref val) = self.addtl_rsn_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_rsn_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 210 {
				return Err(ValidationError::new(1002, "addtl_rsn_inf exceeds the maximum length of 210".to_string()));
			}
		}
		Ok(())
	}
}


// PendingReason17 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PendingReason17 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd") )]
	pub cd: PendingReason30Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlRsnInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_rsn_inf: Option<String>,
}

impl PendingReason17 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.cd.validate()?;
		if let Some(ref val) = self.addtl_rsn_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_rsn_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 210 {
				return Err(ValidationError::new(1002, "addtl_rsn_inf exceeds the maximum length of 210".to_string()));
			}
		}
		Ok(())
	}
}


// PendingReason26Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PendingReason26Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<PendingReason10Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl PendingReason26Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// PendingReason28Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PendingReason28Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<PendingReason6Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl PendingReason28Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// PendingReason30Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PendingReason30Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<PendingReason9Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl PendingReason30Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// PendingReason6Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PendingReason6Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ADEA") )]
	CodeADEA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CONF") )]
	CodeCONF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CDRG") )]
	CodeCDRG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CDCY") )]
	CodeCDCY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CDRE") )]
	CodeCDRE,
}

impl PendingReason6Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PendingReason9Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PendingReason9Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ADEA") )]
	CodeADEA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CONF") )]
	CodeCONF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CDRG") )]
	CodeCDRG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CDCY") )]
	CodeCDCY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CDRE") )]
	CodeCDRE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CDAC") )]
	CodeCDAC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INBC") )]
	CodeINBC,
}

impl PendingReason9Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PendingSettlement2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PendingSettlement2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "AWMO") )]
	CodeAWMO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CAIS") )]
	CodeCAIS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REFU") )]
	CodeREFU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AWSH") )]
	CodeAWSH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PHSE") )]
	CodePHSE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TAMM") )]
	CodeTAMM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DOCY") )]
	CodeDOCY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DOCC") )]
	CodeDOCC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BLOC") )]
	CodeBLOC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CHAS") )]
	CodeCHAS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NEWI") )]
	CodeNEWI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CLAC") )]
	CodeCLAC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MUNO") )]
	CodeMUNO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GLOB") )]
	CodeGLOB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PREA") )]
	CodePREA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GUAD") )]
	CodeGUAD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PART") )]
	CodePART,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NMAS") )]
	CodeNMAS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CMON") )]
	CodeCMON,
	#[cfg_attr( feature = "derive_serde", serde(rename = "YCOL") )]
	CodeYCOL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "COLL") )]
	CodeCOLL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DEPO") )]
	CodeDEPO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FLIM") )]
	CodeFLIM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NOFX") )]
	CodeNOFX,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INCA") )]
	CodeINCA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LINK") )]
	CodeLINK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FUTU") )]
	CodeFUTU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LACK") )]
	CodeLACK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LALO") )]
	CodeLALO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MONY") )]
	CodeMONY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NCON") )]
	CodeNCON,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REFS") )]
	CodeREFS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SDUT") )]
	CodeSDUT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BATC") )]
	CodeBATC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CYCL") )]
	CodeCYCL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SBLO") )]
	CodeSBLO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CPEC") )]
	CodeCPEC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MINO") )]
	CodeMINO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PCAP") )]
	CodePCAP,
}

impl PendingSettlement2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PendingStatus36Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PendingStatus36Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NoSpcfdRsn", skip_serializing_if = "Option::is_none") )]
	pub no_spcfd_rsn: Option<NoReasonCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<Vec<PendingReason14>>,
}

impl PendingStatus36Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.no_spcfd_rsn { val.validate()? }
		if let Some(ref vec) = self.rsn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// PendingStatus38Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PendingStatus38Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NoSpcfdRsn", skip_serializing_if = "Option::is_none") )]
	pub no_spcfd_rsn: Option<NoReasonCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<Vec<PendingReason16>>,
}

impl PendingStatus38Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.no_spcfd_rsn { val.validate()? }
		if let Some(ref vec) = self.rsn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// PendingStatus39Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PendingStatus39Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NoSpcfdRsn", skip_serializing_if = "Option::is_none") )]
	pub no_spcfd_rsn: Option<NoReasonCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<Vec<PendingReason17>>,
}

impl PendingStatus39Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.no_spcfd_rsn { val.validate()? }
		if let Some(ref vec) = self.rsn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// PendingStatus4Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PendingStatus4Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACPD") )]
	CodeACPD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VALD") )]
	CodeVALD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MATD") )]
	CodeMATD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AUTD") )]
	CodeAUTD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INVD") )]
	CodeINVD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UMAC") )]
	CodeUMAC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "STLE") )]
	CodeSTLE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "STLM") )]
	CodeSTLM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SSPD") )]
	CodeSSPD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PCAN") )]
	CodePCAN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PSTL") )]
	CodePSTL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PFST") )]
	CodePFST,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SMLR") )]
	CodeSMLR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RMLR") )]
	CodeRMLR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SRBL") )]
	CodeSRBL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AVLB") )]
	CodeAVLB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SRML") )]
	CodeSRML,
}

impl PendingStatus4Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PendingStatusAndReason2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PendingStatusAndReason2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrcgSts", skip_serializing_if = "Option::is_none") )]
	pub prcg_sts: Option<Vec<ProcessingStatus66Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmSts", skip_serializing_if = "Option::is_none") )]
	pub sttlm_sts: Option<Vec<SettlementStatus16Choice>>,
}

impl PendingStatusAndReason2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.prcg_sts { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.sttlm_sts { for item in vec { item.validate()? } }
		Ok(())
	}
}


// PendingStatusReason14 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PendingStatusReason14 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd") )]
	pub cd: PendingStatusReason2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
}

impl PendingStatusReason14 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.cd.validate()?;
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 350".to_string()));
			}
		}
		Ok(())
	}
}


// PendingStatusReason1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PendingStatusReason1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NoSpcfdRsn", skip_serializing_if = "Option::is_none") )]
	pub no_spcfd_rsn: Option<NoReasonCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<Vec<PendingStatusReason14>>,
}

impl PendingStatusReason1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.no_spcfd_rsn { val.validate()? }
		if let Some(ref vec) = self.rsn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// PendingStatusReason1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PendingStatusReason1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "KYCM") )]
	CodeKYCM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FRDM") )]
	CodeFRDM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RIGH") )]
	CodeRIGH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ATHR") )]
	CodeATHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ATHP") )]
	CodeATHP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MODI") )]
	CodeMODI,
}

impl PendingStatusReason1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PendingStatusReason2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PendingStatusReason2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<PendingStatusReason1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification36>,
}

impl PendingStatusReason2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// PercentageRange1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PercentageRange1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Fr", skip_serializing_if = "Option::is_none") )]
	pub fr: Option<PercentageRangeBoundary1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "To", skip_serializing_if = "Option::is_none") )]
	pub to: Option<PercentageRangeBoundary1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrTo", skip_serializing_if = "Option::is_none") )]
	pub fr_to: Option<FromToPercentageRange1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EQ", skip_serializing_if = "Option::is_none") )]
	pub eq: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NEQ", skip_serializing_if = "Option::is_none") )]
	pub neq: Option<f64>,
}

impl PercentageRange1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.fr { val.validate()? }
		if let Some(ref val) = self.to { val.validate()? }
		if let Some(ref val) = self.fr_to { val.validate()? }
		Ok(())
	}
}


// PercentageRangeBoundary1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PercentageRangeBoundary1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BdryRate") )]
	pub bdry_rate: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Incl") )]
	pub incl: bool,
}

impl PercentageRangeBoundary1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PerformanceFactors1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PerformanceFactors1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CorpActnFctr", skip_serializing_if = "Option::is_none") )]
	pub corp_actn_fctr: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CmltvCorpActnFctr", skip_serializing_if = "Option::is_none") )]
	pub cmltv_corp_actn_fctr: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcmltnPrd", skip_serializing_if = "Option::is_none") )]
	pub acmltn_prd: Option<DatePeriodDetails>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NrmlPrfrmnc", skip_serializing_if = "Option::is_none") )]
	pub nrml_prfrmnc: Option<f64>,
}

impl PerformanceFactors1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.acmltn_prd { val.validate()? }
		Ok(())
	}
}


// Period11Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Period11Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dt", skip_serializing_if = "Option::is_none") )]
	pub dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrDt", skip_serializing_if = "Option::is_none") )]
	pub fr_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ToDt", skip_serializing_if = "Option::is_none") )]
	pub to_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrToDt", skip_serializing_if = "Option::is_none") )]
	pub fr_to_dt: Option<Period2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrToDtTm", skip_serializing_if = "Option::is_none") )]
	pub fr_to_dt_tm: Option<DateTimePeriod1>,
}

impl Period11Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.fr_to_dt { val.validate()? }
		if let Some(ref val) = self.fr_to_dt_tm { val.validate()? }
		Ok(())
	}
}


// Period15 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Period15 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "StartDt") )]
	pub start_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndDt") )]
	pub end_dt: String,
}

impl Period15 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Period2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Period2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrDt") )]
	pub fr_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ToDt") )]
	pub to_dt: String,
}

impl Period2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Period4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Period4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dt", skip_serializing_if = "Option::is_none") )]
	pub dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrDt", skip_serializing_if = "Option::is_none") )]
	pub fr_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ToDt", skip_serializing_if = "Option::is_none") )]
	pub to_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrDtToDt", skip_serializing_if = "Option::is_none") )]
	pub fr_dt_to_dt: Option<Period2>,
}

impl Period4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.fr_dt_to_dt { val.validate()? }
		Ok(())
	}
}


// Period7Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Period7Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrDtTmToDtTm", skip_serializing_if = "Option::is_none") )]
	pub fr_dt_tm_to_dt_tm: Option<DateTimePeriod1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrDtToDt", skip_serializing_if = "Option::is_none") )]
	pub fr_dt_to_dt: Option<Period2>,
}

impl Period7Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.fr_dt_tm_to_dt_tm { val.validate()? }
		if let Some(ref val) = self.fr_dt_to_dt { val.validate()? }
		Ok(())
	}
}


// PersonIdentification10 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PersonIdentification10 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrstNm") )]
	pub frst_nm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm") )]
	pub nm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BirthDt") )]
	pub birth_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr") )]
	pub othr: GenericPersonIdentification1,
}

impl PersonIdentification10 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.frst_nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "frst_nm is shorter than the minimum length of 1".to_string()));
		}
		if self.frst_nm.chars().count() > 140 {
			return Err(ValidationError::new(1002, "frst_nm exceeds the maximum length of 140".to_string()));
		}
		if self.nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
		}
		if self.nm.chars().count() > 140 {
			return Err(ValidationError::new(1002, "nm exceeds the maximum length of 140".to_string()));
		}
		self.othr.validate()?;
		Ok(())
	}
}


// PersonIdentification12 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PersonIdentification12 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtryOfBrnch") )]
	pub ctry_of_brnch: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr") )]
	pub othr: GenericPersonIdentification1,
}

impl PersonIdentification12 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{2,2}").unwrap();
		if !pattern.is_match(&self.ctry_of_brnch) {
			return Err(ValidationError::new(1005, "ctry_of_brnch does not match the required pattern".to_string()));
		}
		self.othr.validate()?;
		Ok(())
	}
}


// PersonIdentification13 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PersonIdentification13 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtAndPlcOfBirth", skip_serializing_if = "Option::is_none") )]
	pub dt_and_plc_of_birth: Option<DateAndPlaceOfBirth1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<Vec<GenericPersonIdentification1>>,
}

impl PersonIdentification13 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.dt_and_plc_of_birth { val.validate()? }
		if let Some(ref vec) = self.othr { for item in vec { item.validate()? } }
		Ok(())
	}
}


// PersonIdentification18 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PersonIdentification18 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtAndPlcOfBirth", skip_serializing_if = "Option::is_none") )]
	pub dt_and_plc_of_birth: Option<DateAndPlaceOfBirth1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<Vec<GenericPersonIdentification2>>,
}

impl PersonIdentification18 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.dt_and_plc_of_birth { val.validate()? }
		if let Some(ref vec) = self.othr { for item in vec { item.validate()? } }
		Ok(())
	}
}


// PersonIdentification20 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PersonIdentification20 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtAndPlcOfBirth", skip_serializing_if = "Option::is_none") )]
	pub dt_and_plc_of_birth: Option<DateAndPlaceOfBirth1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EmailAdr", skip_serializing_if = "Option::is_none") )]
	pub email_adr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<Vec<GenericPersonIdentification2>>,
}

impl PersonIdentification20 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.dt_and_plc_of_birth { val.validate()? }
		if let Some(ref val) = self.email_adr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "email_adr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 256 {
				return Err(ValidationError::new(1002, "email_adr exceeds the maximum length of 256".to_string()));
			}
		}
		if let Some(ref vec) = self.othr { for item in vec { item.validate()? } }
		Ok(())
	}
}


// PersonIdentification5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PersonIdentification5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtAndPlcOfBirth", skip_serializing_if = "Option::is_none") )]
	pub dt_and_plc_of_birth: Option<DateAndPlaceOfBirth>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<Vec<GenericPersonIdentification1>>,
}

impl PersonIdentification5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.dt_and_plc_of_birth { val.validate()? }
		if let Some(ref vec) = self.othr { for item in vec { item.validate()? } }
		Ok(())
	}
}


// PersonIdentificationSchemeName1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PersonIdentificationSchemeName1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl PersonIdentificationSchemeName1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// PersonIdentificationType5Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PersonIdentificationType5Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "AREG") )]
	CodeAREG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CPFA") )]
	CodeCPFA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DRLC") )]
	CodeDRLC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EMID") )]
	CodeEMID,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IDCD") )]
	CodeIDCD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NRIN") )]
	CodeNRIN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PASS") )]
	CodePASS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "POCD") )]
	CodePOCD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SOCS") )]
	CodeSOCS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SRSA") )]
	CodeSRSA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GUNL") )]
	CodeGUNL,
}

impl PersonIdentificationType5Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PersonOrOrganisation1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PersonOrOrganisation1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "LEI", skip_serializing_if = "Option::is_none") )]
	pub lei: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MIC", skip_serializing_if = "Option::is_none") )]
	pub mic: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prsn", skip_serializing_if = "Option::is_none") )]
	pub prsn: Option<PersonIdentification10>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Intl", skip_serializing_if = "Option::is_none") )]
	pub intl: Option<InternalPartyRole1Code>,
}

impl PersonOrOrganisation1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.lei {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "lei does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.mic {
			let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "mic does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.prsn { val.validate()? }
		if let Some(ref val) = self.intl { val.validate()? }
		Ok(())
	}
}


// PersonOrOrganisation2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PersonOrOrganisation2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "LEI", skip_serializing_if = "Option::is_none") )]
	pub lei: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prsn", skip_serializing_if = "Option::is_none") )]
	pub prsn: Option<PersonIdentification10>,
}

impl PersonOrOrganisation2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.lei {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "lei does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.prsn { val.validate()? }
		Ok(())
	}
}


// PersonOrOrganisation4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PersonOrOrganisation4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "LEI", skip_serializing_if = "Option::is_none") )]
	pub lei: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prsn", skip_serializing_if = "Option::is_none") )]
	pub prsn: Option<GenericPersonIdentification1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XcptnId", skip_serializing_if = "Option::is_none") )]
	pub xcptn_id: Option<PartyExceptionType1Code>,
}

impl PersonOrOrganisation4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.lei {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "lei does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.prsn { val.validate()? }
		if let Some(ref val) = self.xcptn_id { val.validate()? }
		Ok(())
	}
}


// PersonType2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PersonType2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtAndPlcOfBirth", skip_serializing_if = "Option::is_none") )]
	pub dt_and_plc_of_birth: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EmailAdr", skip_serializing_if = "Option::is_none") )]
	pub email_adr: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<Vec<GenericPersonType1>>,
}

impl PersonType2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.othr { for item in vec { item.validate()? } }
		Ok(())
	}
}


// PersonalInformation1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PersonalInformation1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NmOfFthr", skip_serializing_if = "Option::is_none") )]
	pub nm_of_fthr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MdnNmOfMthr", skip_serializing_if = "Option::is_none") )]
	pub mdn_nm_of_mthr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NmOfPrtnr", skip_serializing_if = "Option::is_none") )]
	pub nm_of_prtnr: Option<String>,
}

impl PersonalInformation1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nm_of_fthr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm_of_fthr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "nm_of_fthr exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.mdn_nm_of_mthr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mdn_nm_of_mthr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "mdn_nm_of_mthr exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.nm_of_prtnr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm_of_prtnr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "nm_of_prtnr exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// PhysicalTransferType4Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PhysicalTransferType4Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "PHYS") )]
	CodePHYS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OPTL") )]
	CodeOPTL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CASH") )]
	CodeCASH,
}

impl PhysicalTransferType4Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PlainCardData1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PlainCardData1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PAN") )]
	pub pan: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CardSeqNb", skip_serializing_if = "Option::is_none") )]
	pub card_seq_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FctvDt", skip_serializing_if = "Option::is_none") )]
	pub fctv_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XpryDt") )]
	pub xpry_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SvcCd", skip_serializing_if = "Option::is_none") )]
	pub svc_cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrckData", skip_serializing_if = "Option::is_none") )]
	pub trck_data: Option<Vec<TrackData1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CardSctyCd", skip_serializing_if = "Option::is_none") )]
	pub card_scty_cd: Option<CardSecurityInformation1>,
}

impl PlainCardData1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[0-9]{8,28}").unwrap();
		if !pattern.is_match(&self.pan) {
			return Err(ValidationError::new(1005, "pan does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.card_seq_nb {
			let pattern = Regex::new("[0-9]{2,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "card_seq_nb does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.svc_cd {
			let pattern = Regex::new("[0-9]{3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "svc_cd does not match the required pattern".to_string()));
			}
		}
		if let Some(ref vec) = self.trck_data { for item in vec { item.validate()? } }
		if let Some(ref val) = self.card_scty_cd { val.validate()? }
		Ok(())
	}
}


// PlanStatus1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PlanStatus1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACTV") )]
	CodeACTV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CLOS") )]
	CodeCLOS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SUSP") )]
	CodeSUSP,
}

impl PlanStatus1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PlanStatus2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PlanStatus2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<PlanStatus1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl PlanStatus2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// PointOfInteraction1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PointOfInteraction1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: GenericIdentification32,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SysNm", skip_serializing_if = "Option::is_none") )]
	pub sys_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GrpId", skip_serializing_if = "Option::is_none") )]
	pub grp_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cpblties", skip_serializing_if = "Option::is_none") )]
	pub cpblties: Option<PointOfInteractionCapabilities1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cmpnt", skip_serializing_if = "Option::is_none") )]
	pub cmpnt: Option<Vec<PointOfInteractionComponent1>>,
}

impl PointOfInteraction1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.id.validate()?;
		if let Some(ref val) = self.sys_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "sys_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "sys_nm exceeds the maximum length of 70".to_string()));
			}
		}
		if let Some(ref val) = self.grp_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "grp_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "grp_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.cpblties { val.validate()? }
		if let Some(ref vec) = self.cmpnt { for item in vec { item.validate()? } }
		Ok(())
	}
}


// PointOfInteractionCapabilities1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PointOfInteractionCapabilities1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CardRdngCpblties", skip_serializing_if = "Option::is_none") )]
	pub card_rdng_cpblties: Option<Vec<CardDataReading1Code>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CrdhldrVrfctnCpblties", skip_serializing_if = "Option::is_none") )]
	pub crdhldr_vrfctn_cpblties: Option<Vec<CardholderVerificationCapability1Code>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OnLineCpblties", skip_serializing_if = "Option::is_none") )]
	pub on_line_cpblties: Option<OnLineCapability1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DispCpblties", skip_serializing_if = "Option::is_none") )]
	pub disp_cpblties: Option<Vec<DisplayCapabilities1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtLineWidth", skip_serializing_if = "Option::is_none") )]
	pub prt_line_width: Option<String>,
}

impl PointOfInteractionCapabilities1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.card_rdng_cpblties { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.crdhldr_vrfctn_cpblties { for item in vec { item.validate()? } }
		if let Some(ref val) = self.on_line_cpblties { val.validate()? }
		if let Some(ref vec) = self.disp_cpblties { for item in vec { item.validate()? } }
		if let Some(ref val) = self.prt_line_width {
			let pattern = Regex::new("[0-9]{1,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "prt_line_width does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// PointOfInteractionComponent1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PointOfInteractionComponent1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "POICmpntTp") )]
	pub poi_cmpnt_tp: POIComponentType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ManfctrId", skip_serializing_if = "Option::is_none") )]
	pub manfctr_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mdl", skip_serializing_if = "Option::is_none") )]
	pub mdl: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VrsnNb", skip_serializing_if = "Option::is_none") )]
	pub vrsn_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SrlNb", skip_serializing_if = "Option::is_none") )]
	pub srl_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ApprvlNb", skip_serializing_if = "Option::is_none") )]
	pub apprvl_nb: Option<Vec<String>>,
}

impl PointOfInteractionComponent1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.poi_cmpnt_tp.validate()?;
		if let Some(ref val) = self.manfctr_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "manfctr_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "manfctr_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.mdl {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mdl is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "mdl exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.vrsn_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "vrsn_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 16 {
				return Err(ValidationError::new(1002, "vrsn_nb exceeds the maximum length of 16".to_string()));
			}
		}
		if let Some(ref val) = self.srl_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "srl_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "srl_nb exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref vec) = self.apprvl_nb {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "apprvl_nb is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 70 {
					return Err(ValidationError::new(1002, "apprvl_nb exceeds the maximum length of 70".to_string()));
				}
			}
		}
		Ok(())
	}
}


// PoliticalExposureType2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PoliticalExposureType2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<PoliticalExposureType2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl PoliticalExposureType2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// PoliticalExposureType2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PoliticalExposureType2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "NPEX") )]
	CodeNPEX,
	#[cfg_attr( feature = "derive_serde", serde(rename = "YPEX") )]
	CodeYPEX,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PEXD") )]
	CodePEXD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PEXF") )]
	CodePEXF,
}

impl PoliticalExposureType2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PoliticallyExposedPerson1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PoliticallyExposedPerson1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PltclyXpsdPrsnTp") )]
	pub pltcly_xpsd_prsn_tp: PoliticalExposureType2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PltclyXpsdPrsnSts", skip_serializing_if = "Option::is_none") )]
	pub pltcly_xpsd_prsn_sts: Option<PoliticallyExposedPersonStatus1Choice>,
}

impl PoliticallyExposedPerson1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pltcly_xpsd_prsn_tp.validate()?;
		if let Some(ref val) = self.pltcly_xpsd_prsn_sts { val.validate()? }
		Ok(())
	}
}


// PoliticallyExposedPersonStatus1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PoliticallyExposedPersonStatus1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<PoliticallyExposedPersonStatus1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl PoliticallyExposedPersonStatus1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// PoliticallyExposedPersonStatus1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PoliticallyExposedPersonStatus1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "PE03") )]
	CodePE03,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PE01") )]
	CodePE01,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PE02") )]
	CodePE02,
}

impl PoliticallyExposedPersonStatus1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PolypropyleneCommodityOther1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PolypropyleneCommodityOther1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType9Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct") )]
	pub sub_pdct: AssetClassSubProductType49Code,
}

impl PolypropyleneCommodityOther1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		self.sub_pdct.validate()?;
		Ok(())
	}
}


// PolypropyleneCommodityOther2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PolypropyleneCommodityOther2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType9Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType49Code>,
}

impl PolypropyleneCommodityOther2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// PolypropyleneCommodityPlastic1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PolypropyleneCommodityPlastic1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType9Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType18Code>,
}

impl PolypropyleneCommodityPlastic1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// PolypropyleneCommodityPlastic2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PolypropyleneCommodityPlastic2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct") )]
	pub base_pdct: AssetClassProductType9Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<AssetClassSubProductType18Code>,
}

impl PolypropyleneCommodityPlastic2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_pdct.validate()?;
		if let Some(ref val) = self.sub_pdct { val.validate()? }
		Ok(())
	}
}


// PortfolioCode3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PortfolioCode3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NoPrtfl", skip_serializing_if = "Option::is_none") )]
	pub no_prtfl: Option<NotApplicable1Code>,
}

impl PortfolioCode3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 52 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 52".to_string()));
			}
		}
		if let Some(ref val) = self.no_prtfl { val.validate()? }
		Ok(())
	}
}


// PortfolioCode5Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PortfolioCode5Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtfl", skip_serializing_if = "Option::is_none") )]
	pub prtfl: Option<PortfolioIdentification3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NoPrtfl", skip_serializing_if = "Option::is_none") )]
	pub no_prtfl: Option<NotApplicable1Code>,
}

impl PortfolioCode5Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.prtfl { val.validate()? }
		if let Some(ref val) = self.no_prtfl { val.validate()? }
		Ok(())
	}
}


// PortfolioIdentification3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PortfolioIdentification3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd") )]
	pub cd: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtflTxXmptn", skip_serializing_if = "Option::is_none") )]
	pub prtfl_tx_xmptn: Option<bool>,
}

impl PortfolioIdentification3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.cd.chars().count() < 1 {
			return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
		}
		if self.cd.chars().count() > 52 {
			return Err(ValidationError::new(1002, "cd exceeds the maximum length of 52".to_string()));
		}
		Ok(())
	}
}


// PortfolioStressTestResult1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PortfolioStressTestResult1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtflId") )]
	pub prtfl_id: GenericIdentification165,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StrssLoss") )]
	pub strss_loss: AmountAndDirection102,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RawStrssLoss", skip_serializing_if = "Option::is_none") )]
	pub raw_strss_loss: Option<AmountAndDirection102>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cover1Flg") )]
	pub cover1_flg: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cover2Flg") )]
	pub cover2_flg: bool,
}

impl PortfolioStressTestResult1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.prtfl_id.validate()?;
		self.strss_loss.validate()?;
		if let Some(ref val) = self.raw_strss_loss { val.validate()? }
		Ok(())
	}
}


// Position1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Position1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PdctId") )]
	pub pdct_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RskRqrmnt", skip_serializing_if = "Option::is_none") )]
	pub rsk_rqrmnt: Option<EndOfDayRequirement1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GrssNtnl") )]
	pub grss_ntnl: ActiveCurrencyAnd24Amount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NetNtnl") )]
	pub net_ntnl: AmountAndDirection102,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GrssDltaEqvtVal", skip_serializing_if = "Option::is_none") )]
	pub grss_dlta_eqvt_val: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NetDltaEqvtVal", skip_serializing_if = "Option::is_none") )]
	pub net_dlta_eqvt_val: Option<AmountAndDirection102>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GrssDltaEqvtQty", skip_serializing_if = "Option::is_none") )]
	pub grss_dlta_eqvt_qty: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NetDltaEqvtQty", skip_serializing_if = "Option::is_none") )]
	pub net_dlta_eqvt_qty: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GrssMktVal") )]
	pub grss_mkt_val: ActiveCurrencyAndAmount,
}

impl Position1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.pdct_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "pdct_id is shorter than the minimum length of 1".to_string()));
		}
		if self.pdct_id.chars().count() > 256 {
			return Err(ValidationError::new(1002, "pdct_id exceeds the maximum length of 256".to_string()));
		}
		if let Some(ref val) = self.rsk_rqrmnt { val.validate()? }
		self.grss_ntnl.validate()?;
		self.net_ntnl.validate()?;
		if let Some(ref val) = self.grss_dlta_eqvt_val { val.validate()? }
		if let Some(ref val) = self.net_dlta_eqvt_val { val.validate()? }
		self.grss_mkt_val.validate()?;
		Ok(())
	}
}


// PositionAccount1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PositionAccount1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: PartyIdentification118Choice,
}

impl PositionAccount1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.id.validate()?;
		Ok(())
	}
}


// PositionAccount2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PositionAccount2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: GenericIdentification165,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pos") )]
	pub pos: Vec<Position1>,
}

impl PositionAccount2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.id.validate()?;
		for item in &self.pos { item.validate()? }
		Ok(())
	}
}


// PositionEffect3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PositionEffect3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "FIFO") )]
	CodeFIFO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LIFO") )]
	CodeLIFO,
}

impl PositionEffect3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PositionSet16 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PositionSet16 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dmnsns") )]
	pub dmnsns: PositionSetDimensions14,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mtrcs") )]
	pub mtrcs: PositionSetMetrics7,
}

impl PositionSet16 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.dmnsns.validate()?;
		self.mtrcs.validate()?;
		Ok(())
	}
}


// PositionSet17 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PositionSet17 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dmnsns") )]
	pub dmnsns: PositionSetDimensions14,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mtrcs") )]
	pub mtrcs: PositionSetMetrics13,
}

impl PositionSet17 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.dmnsns.validate()?;
		self.mtrcs.validate()?;
		Ok(())
	}
}


// PositionSet18 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PositionSet18 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dmnsns") )]
	pub dmnsns: PositionSetDimensions14,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mtrcs") )]
	pub mtrcs: PositionSetMetrics12,
}

impl PositionSet18 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.dmnsns.validate()?;
		self.mtrcs.validate()?;
		Ok(())
	}
}


// PositionSet19 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PositionSet19 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dmnsns") )]
	pub dmnsns: PositionSetDimensions12,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mtrcs") )]
	pub mtrcs: PositionSetMetrics11,
}

impl PositionSet19 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.dmnsns.validate()?;
		self.mtrcs.validate()?;
		Ok(())
	}
}


// PositionSet20 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PositionSet20 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dmnsns") )]
	pub dmnsns: PositionSetDimensions15,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mtrcs") )]
	pub mtrcs: PositionSetMetrics10,
}

impl PositionSet20 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.dmnsns.validate()?;
		self.mtrcs.validate()?;
		Ok(())
	}
}


// PositionSet21 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PositionSet21 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dmnsns") )]
	pub dmnsns: PositionSetDimensions16,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mtrcs") )]
	pub mtrcs: PositionSetMetrics14,
}

impl PositionSet21 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.dmnsns.validate()?;
		self.mtrcs.validate()?;
		Ok(())
	}
}


// PositionSet22 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PositionSet22 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dmnsns") )]
	pub dmnsns: PositionSetCollateralDimensions3,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mtrcs") )]
	pub mtrcs: PositionSetCollateralMetrics2,
}

impl PositionSet22 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.dmnsns.validate()?;
		self.mtrcs.validate()?;
		Ok(())
	}
}


// PositionSetAggregated2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PositionSetAggregated2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DataSetActn", skip_serializing_if = "Option::is_none") )]
	pub data_set_actn: Option<ReportPeriodActivity1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rpt", skip_serializing_if = "Option::is_none") )]
	pub rpt: Option<PositionSetAggregated4>,
}

impl PositionSetAggregated2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.data_set_actn { val.validate()? }
		if let Some(ref val) = self.rpt { val.validate()? }
		Ok(())
	}
}


// PositionSetAggregated4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PositionSetAggregated4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RefDt") )]
	pub ref_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PosSet", skip_serializing_if = "Option::is_none") )]
	pub pos_set: Option<Vec<PositionSet21>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CcyPosSet", skip_serializing_if = "Option::is_none") )]
	pub ccy_pos_set: Option<Vec<PositionSet21>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollPosSet", skip_serializing_if = "Option::is_none") )]
	pub coll_pos_set: Option<Vec<PositionSet22>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CcyCollPosSet", skip_serializing_if = "Option::is_none") )]
	pub ccy_coll_pos_set: Option<Vec<PositionSet22>>,
}

impl PositionSetAggregated4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.pos_set { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.ccy_pos_set { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.coll_pos_set { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.ccy_coll_pos_set { for item in vec { item.validate()? } }
		Ok(())
	}
}


// PositionSetBuyerAndSeller2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PositionSetBuyerAndSeller2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Buyr", skip_serializing_if = "Option::is_none") )]
	pub buyr: Option<PositionSetTotal2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sellr", skip_serializing_if = "Option::is_none") )]
	pub sellr: Option<PositionSetTotal2>,
}

impl PositionSetBuyerAndSeller2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.buyr { val.validate()? }
		if let Some(ref val) = self.sellr { val.validate()? }
		Ok(())
	}
}


// PositionSetCollateralDimensions3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PositionSetCollateralDimensions3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtyId", skip_serializing_if = "Option::is_none") )]
	pub ctr_pty_id: Option<TradeCounterpartyReport20>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Coll", skip_serializing_if = "Option::is_none") )]
	pub coll: Option<MarginCollateralReport4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitlMrgnPstdCcy", skip_serializing_if = "Option::is_none") )]
	pub initl_mrgn_pstd_ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VartnMrgnPstdCcy", skip_serializing_if = "Option::is_none") )]
	pub vartn_mrgn_pstd_ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitlMrgnRcvdCcy", skip_serializing_if = "Option::is_none") )]
	pub initl_mrgn_rcvd_ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VartnMrgnRcvdCcy", skip_serializing_if = "Option::is_none") )]
	pub vartn_mrgn_rcvd_ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XcssCollPstdCcy", skip_serializing_if = "Option::is_none") )]
	pub xcss_coll_pstd_ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XcssCollRcvdCcy", skip_serializing_if = "Option::is_none") )]
	pub xcss_coll_rcvd_ccy: Option<String>,
}

impl PositionSetCollateralDimensions3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ctr_pty_id { val.validate()? }
		if let Some(ref val) = self.coll { val.validate()? }
		if let Some(ref val) = self.initl_mrgn_pstd_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "initl_mrgn_pstd_ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.vartn_mrgn_pstd_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "vartn_mrgn_pstd_ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.initl_mrgn_rcvd_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "initl_mrgn_rcvd_ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.vartn_mrgn_rcvd_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "vartn_mrgn_rcvd_ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.xcss_coll_pstd_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "xcss_coll_pstd_ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.xcss_coll_rcvd_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "xcss_coll_rcvd_ccy does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// PositionSetCollateralMetrics2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PositionSetCollateralMetrics2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ttl", skip_serializing_if = "Option::is_none") )]
	pub ttl: Option<PositionSetCollateralTotal2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Clean", skip_serializing_if = "Option::is_none") )]
	pub clean: Option<PositionSetCollateralTotal2>,
}

impl PositionSetCollateralMetrics2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ttl { val.validate()? }
		if let Some(ref val) = self.clean { val.validate()? }
		Ok(())
	}
}


// PositionSetCollateralTotal2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PositionSetCollateralTotal2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfRpts", skip_serializing_if = "Option::is_none") )]
	pub nb_of_rpts: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstdMrgnOrColl", skip_serializing_if = "Option::is_none") )]
	pub pstd_mrgn_or_coll: Option<PostedMarginOrCollateral6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RcvdMrgnOrColl", skip_serializing_if = "Option::is_none") )]
	pub rcvd_mrgn_or_coll: Option<ReceivedMarginOrCollateral6>,
}

impl PositionSetCollateralTotal2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.pstd_mrgn_or_coll { val.validate()? }
		if let Some(ref val) = self.rcvd_mrgn_or_coll { val.validate()? }
		Ok(())
	}
}


// PositionSetDimensions12 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PositionSetDimensions12 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgCtrPty", skip_serializing_if = "Option::is_none") )]
	pub rptg_ctr_pty: Option<OrganisationIdentification15Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollData", skip_serializing_if = "Option::is_none") )]
	pub coll_data: Option<CollateralData33>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OtlrsIncl", skip_serializing_if = "Option::is_none") )]
	pub otlrs_incl: Option<bool>,
}

impl PositionSetDimensions12 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rptg_ctr_pty { val.validate()? }
		if let Some(ref val) = self.coll_data { val.validate()? }
		Ok(())
	}
}


// PositionSetDimensions14 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PositionSetDimensions14 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtyData", skip_serializing_if = "Option::is_none") )]
	pub ctr_pty_data: Option<CounterpartyData86>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LnData", skip_serializing_if = "Option::is_none") )]
	pub ln_data: Option<LoanData134>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollData", skip_serializing_if = "Option::is_none") )]
	pub coll_data: Option<CollateralData33>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OtlrsIncl", skip_serializing_if = "Option::is_none") )]
	pub otlrs_incl: Option<bool>,
}

impl PositionSetDimensions14 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ctr_pty_data { val.validate()? }
		if let Some(ref val) = self.ln_data { val.validate()? }
		if let Some(ref val) = self.coll_data { val.validate()? }
		Ok(())
	}
}


// PositionSetDimensions15 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PositionSetDimensions15 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgCtrPty", skip_serializing_if = "Option::is_none") )]
	pub rptg_ctr_pty: Option<OrganisationIdentification15Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrCtrPty", skip_serializing_if = "Option::is_none") )]
	pub othr_ctr_pty: Option<OrganisationIdentification15Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollPrtflId", skip_serializing_if = "Option::is_none") )]
	pub coll_prtfl_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OtlrsIncl", skip_serializing_if = "Option::is_none") )]
	pub otlrs_incl: Option<bool>,
}

impl PositionSetDimensions15 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rptg_ctr_pty { val.validate()? }
		if let Some(ref val) = self.othr_ctr_pty { val.validate()? }
		if let Some(ref val) = self.coll_prtfl_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "coll_prtfl_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 52 {
				return Err(ValidationError::new(1002, "coll_prtfl_id exceeds the maximum length of 52".to_string()));
			}
		}
		Ok(())
	}
}


// PositionSetDimensions16 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PositionSetDimensions16 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtyId", skip_serializing_if = "Option::is_none") )]
	pub ctr_pty_id: Option<TradeCounterpartyReport20>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValCcy", skip_serializing_if = "Option::is_none") )]
	pub val_ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Coll", skip_serializing_if = "Option::is_none") )]
	pub coll: Option<MarginCollateralReport4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctTp", skip_serializing_if = "Option::is_none") )]
	pub ctrct_tp: Option<FinancialInstrumentContractType2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AsstClss", skip_serializing_if = "Option::is_none") )]
	pub asst_clss: Option<ProductType4Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UndrlygInstrm", skip_serializing_if = "Option::is_none") )]
	pub undrlyg_instrm: Option<SecurityIdentification41Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtnlCcy", skip_serializing_if = "Option::is_none") )]
	pub ntnl_ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtnlCcyScndLeg", skip_serializing_if = "Option::is_none") )]
	pub ntnl_ccy_scnd_leg: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmCcy", skip_serializing_if = "Option::is_none") )]
	pub sttlm_ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmCcyScndLeg", skip_serializing_if = "Option::is_none") )]
	pub sttlm_ccy_scnd_leg: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MstrAgrmt", skip_serializing_if = "Option::is_none") )]
	pub mstr_agrmt: Option<MasterAgreement8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Clrd", skip_serializing_if = "Option::is_none") )]
	pub clrd: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntraGrp", skip_serializing_if = "Option::is_none") )]
	pub intra_grp: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XchgRateBsis", skip_serializing_if = "Option::is_none") )]
	pub xchg_rate_bsis: Option<ExchangeRateBasis1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OptnTp", skip_serializing_if = "Option::is_none") )]
	pub optn_tp: Option<OptionType2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TmToMtrty", skip_serializing_if = "Option::is_none") )]
	pub tm_to_mtrty: Option<TimeToMaturity1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IRSTp", skip_serializing_if = "Option::is_none") )]
	pub irs_tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cdt", skip_serializing_if = "Option::is_none") )]
	pub cdt: Option<CreditDerivative7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cmmdty", skip_serializing_if = "Option::is_none") )]
	pub cmmdty: Option<AssetClassCommodity6Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrPmt", skip_serializing_if = "Option::is_none") )]
	pub othr_pmt: Option<OtherPayment6>,
}

impl PositionSetDimensions16 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ctr_pty_id { val.validate()? }
		if let Some(ref val) = self.val_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "val_ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.coll { val.validate()? }
		if let Some(ref val) = self.ctrct_tp { val.validate()? }
		if let Some(ref val) = self.asst_clss { val.validate()? }
		if let Some(ref val) = self.undrlyg_instrm { val.validate()? }
		if let Some(ref val) = self.ntnl_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ntnl_ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.ntnl_ccy_scnd_leg {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ntnl_ccy_scnd_leg does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.sttlm_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "sttlm_ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.sttlm_ccy_scnd_leg {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "sttlm_ccy_scnd_leg does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.mstr_agrmt { val.validate()? }
		if let Some(ref val) = self.xchg_rate_bsis { val.validate()? }
		if let Some(ref val) = self.optn_tp { val.validate()? }
		if let Some(ref val) = self.tm_to_mtrty { val.validate()? }
		if let Some(ref val) = self.irs_tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "irs_tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 52 {
				return Err(ValidationError::new(1002, "irs_tp exceeds the maximum length of 52".to_string()));
			}
		}
		if let Some(ref val) = self.cdt { val.validate()? }
		if let Some(ref val) = self.cmmdty { val.validate()? }
		if let Some(ref val) = self.othr_pmt { val.validate()? }
		Ok(())
	}
}


// PositionSetMetrics10 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PositionSetMetrics10 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "VolMtrcs", skip_serializing_if = "Option::is_none") )]
	pub vol_mtrcs: Option<ExposureMetrics6>,
}

impl PositionSetMetrics10 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.vol_mtrcs { val.validate()? }
		Ok(())
	}
}


// PositionSetMetrics11 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PositionSetMetrics11 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "VolMtrcs", skip_serializing_if = "Option::is_none") )]
	pub vol_mtrcs: Option<VolumeMetrics4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshRinvstmtRate", skip_serializing_if = "Option::is_none") )]
	pub csh_rinvstmt_rate: Option<f64>,
}

impl PositionSetMetrics11 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.vol_mtrcs { val.validate()? }
		Ok(())
	}
}


// PositionSetMetrics12 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PositionSetMetrics12 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "VolMtrcs", skip_serializing_if = "Option::is_none") )]
	pub vol_mtrcs: Option<VolumeMetrics6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HrcutOrMrgn", skip_serializing_if = "Option::is_none") )]
	pub hrcut_or_mrgn: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QtyOrNmnlAmt", skip_serializing_if = "Option::is_none") )]
	pub qty_or_nmnl_amt: Option<QuantityNominalValue2Choice>,
}

impl PositionSetMetrics12 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.vol_mtrcs { val.validate()? }
		if let Some(ref val) = self.qty_or_nmnl_amt { val.validate()? }
		Ok(())
	}
}


// PositionSetMetrics13 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PositionSetMetrics13 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "VolMtrcs") )]
	pub vol_mtrcs: VolumeMetrics5,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PricMtrcs", skip_serializing_if = "Option::is_none") )]
	pub pric_mtrcs: Option<PriceMetrics3>,
}

impl PositionSetMetrics13 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.vol_mtrcs.validate()?;
		if let Some(ref val) = self.pric_mtrcs { val.validate()? }
		Ok(())
	}
}


// PositionSetMetrics14 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PositionSetMetrics14 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ttl", skip_serializing_if = "Option::is_none") )]
	pub ttl: Option<PositionSetBuyerAndSeller2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Clean", skip_serializing_if = "Option::is_none") )]
	pub clean: Option<PositionSetBuyerAndSeller2>,
}

impl PositionSetMetrics14 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ttl { val.validate()? }
		if let Some(ref val) = self.clean { val.validate()? }
		Ok(())
	}
}


// PositionSetMetrics7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PositionSetMetrics7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "VolMtrcs") )]
	pub vol_mtrcs: VolumeMetrics5,
}

impl PositionSetMetrics7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.vol_mtrcs.validate()?;
		Ok(())
	}
}


// PositionSetReport3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PositionSetReport3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DataSetActn", skip_serializing_if = "Option::is_none") )]
	pub data_set_actn: Option<ReportPeriodActivity1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rpt", skip_serializing_if = "Option::is_none") )]
	pub rpt: Option<NamedPosition3>,
}

impl PositionSetReport3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.data_set_actn { val.validate()? }
		if let Some(ref val) = self.rpt { val.validate()? }
		Ok(())
	}
}


// PositionSetTotal2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PositionSetTotal2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfTrds", skip_serializing_if = "Option::is_none") )]
	pub nb_of_trds: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PostvVal", skip_serializing_if = "Option::is_none") )]
	pub postv_val: Option<ActiveOrHistoricCurrencyAnd19DecimalAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NegVal", skip_serializing_if = "Option::is_none") )]
	pub neg_val: Option<ActiveOrHistoricCurrencyAnd19DecimalAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ntnl", skip_serializing_if = "Option::is_none") )]
	pub ntnl: Option<NotionalAmountLegs6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrPmtAmt", skip_serializing_if = "Option::is_none") )]
	pub othr_pmt_amt: Option<Vec<ActiveOrHistoricCurrencyAnd19DecimalAmount>>,
}

impl PositionSetTotal2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.postv_val { val.validate()? }
		if let Some(ref val) = self.neg_val { val.validate()? }
		if let Some(ref val) = self.ntnl { val.validate()? }
		if let Some(ref vec) = self.othr_pmt_amt { for item in vec { item.validate()? } }
		Ok(())
	}
}


// PostTradeRiskReductionIdentifier1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PostTradeRiskReductionIdentifier1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Strr") )]
	pub strr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
}

impl PostTradeRiskReductionIdentifier1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
		if !pattern.is_match(&self.strr) {
			return Err(ValidationError::new(1005, "strr does not match the required pattern".to_string()));
		}
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 52 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 52".to_string()));
		}
		Ok(())
	}
}


// PostalAddress1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PostalAddress1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AdrTp", skip_serializing_if = "Option::is_none") )]
	pub adr_tp: Option<AddressType2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AdrLine", skip_serializing_if = "Option::is_none") )]
	pub adr_line: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StrtNm", skip_serializing_if = "Option::is_none") )]
	pub strt_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BldgNb", skip_serializing_if = "Option::is_none") )]
	pub bldg_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstCd", skip_serializing_if = "Option::is_none") )]
	pub pst_cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TwnNm", skip_serializing_if = "Option::is_none") )]
	pub twn_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrySubDvsn", skip_serializing_if = "Option::is_none") )]
	pub ctry_sub_dvsn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctry") )]
	pub ctry: String,
}

impl PostalAddress1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.adr_tp { val.validate()? }
		if let Some(ref vec) = self.adr_line {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "adr_line is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 70 {
					return Err(ValidationError::new(1002, "adr_line exceeds the maximum length of 70".to_string()));
				}
			}
		}
		if let Some(ref val) = self.strt_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "strt_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "strt_nm exceeds the maximum length of 70".to_string()));
			}
		}
		if let Some(ref val) = self.bldg_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "bldg_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 16 {
				return Err(ValidationError::new(1002, "bldg_nb exceeds the maximum length of 16".to_string()));
			}
		}
		if let Some(ref val) = self.pst_cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pst_cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 16 {
				return Err(ValidationError::new(1002, "pst_cd exceeds the maximum length of 16".to_string()));
			}
		}
		if let Some(ref val) = self.twn_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "twn_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "twn_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.ctry_sub_dvsn {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ctry_sub_dvsn is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "ctry_sub_dvsn exceeds the maximum length of 35".to_string()));
			}
		}
		let pattern = Regex::new("[A-Z]{2,2}").unwrap();
		if !pattern.is_match(&self.ctry) {
			return Err(ValidationError::new(1005, "ctry does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// PostalAddress21 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PostalAddress21 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AdrTp", skip_serializing_if = "Option::is_none") )]
	pub adr_tp: Option<AddressType2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MlngInd", skip_serializing_if = "Option::is_none") )]
	pub mlng_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegnAdrInd", skip_serializing_if = "Option::is_none") )]
	pub regn_adr_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CareOf", skip_serializing_if = "Option::is_none") )]
	pub care_of: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AdrLine", skip_serializing_if = "Option::is_none") )]
	pub adr_line: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StrtNm", skip_serializing_if = "Option::is_none") )]
	pub strt_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BldgNb", skip_serializing_if = "Option::is_none") )]
	pub bldg_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BldgNm", skip_serializing_if = "Option::is_none") )]
	pub bldg_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstBx", skip_serializing_if = "Option::is_none") )]
	pub pst_bx: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SdInBldg", skip_serializing_if = "Option::is_none") )]
	pub sd_in_bldg: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Flr", skip_serializing_if = "Option::is_none") )]
	pub flr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SuiteId", skip_serializing_if = "Option::is_none") )]
	pub suite_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstCd", skip_serializing_if = "Option::is_none") )]
	pub pst_cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DstrctNm", skip_serializing_if = "Option::is_none") )]
	pub dstrct_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Vllg", skip_serializing_if = "Option::is_none") )]
	pub vllg: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TwnNm", skip_serializing_if = "Option::is_none") )]
	pub twn_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Stat", skip_serializing_if = "Option::is_none") )]
	pub stat: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctry") )]
	pub ctry: String,
}

impl PostalAddress21 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.adr_tp { val.validate()? }
		if let Some(ref val) = self.care_of {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "care_of is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "care_of exceeds the maximum length of 70".to_string()));
			}
		}
		if let Some(ref vec) = self.adr_line {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "adr_line is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 70 {
					return Err(ValidationError::new(1002, "adr_line exceeds the maximum length of 70".to_string()));
				}
			}
		}
		if let Some(ref val) = self.strt_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "strt_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "strt_nm exceeds the maximum length of 70".to_string()));
			}
		}
		if let Some(ref val) = self.bldg_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "bldg_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 16 {
				return Err(ValidationError::new(1002, "bldg_nb exceeds the maximum length of 16".to_string()));
			}
		}
		if let Some(ref val) = self.bldg_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "bldg_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "bldg_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.pst_bx {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pst_bx is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 10 {
				return Err(ValidationError::new(1002, "pst_bx exceeds the maximum length of 10".to_string()));
			}
		}
		if let Some(ref val) = self.sd_in_bldg {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "sd_in_bldg is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "sd_in_bldg exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.flr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "flr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "flr exceeds the maximum length of 70".to_string()));
			}
		}
		if let Some(ref val) = self.suite_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "suite_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 10 {
				return Err(ValidationError::new(1002, "suite_id exceeds the maximum length of 10".to_string()));
			}
		}
		if let Some(ref val) = self.pst_cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pst_cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 16 {
				return Err(ValidationError::new(1002, "pst_cd exceeds the maximum length of 16".to_string()));
			}
		}
		if let Some(ref val) = self.dstrct_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "dstrct_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "dstrct_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.vllg {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "vllg is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "vllg exceeds the maximum length of 70".to_string()));
			}
		}
		if let Some(ref val) = self.twn_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "twn_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "twn_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.stat {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "stat is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "stat exceeds the maximum length of 70".to_string()));
			}
		}
		let pattern = Regex::new("[A-Z]{2,2}").unwrap();
		if !pattern.is_match(&self.ctry) {
			return Err(ValidationError::new(1005, "ctry does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// PostalAddress24 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PostalAddress24 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AdrTp", skip_serializing_if = "Option::is_none") )]
	pub adr_tp: Option<AddressType3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dept", skip_serializing_if = "Option::is_none") )]
	pub dept: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubDept", skip_serializing_if = "Option::is_none") )]
	pub sub_dept: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StrtNm", skip_serializing_if = "Option::is_none") )]
	pub strt_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BldgNb", skip_serializing_if = "Option::is_none") )]
	pub bldg_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BldgNm", skip_serializing_if = "Option::is_none") )]
	pub bldg_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Flr", skip_serializing_if = "Option::is_none") )]
	pub flr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstBx", skip_serializing_if = "Option::is_none") )]
	pub pst_bx: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Room", skip_serializing_if = "Option::is_none") )]
	pub room: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstCd", skip_serializing_if = "Option::is_none") )]
	pub pst_cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TwnNm", skip_serializing_if = "Option::is_none") )]
	pub twn_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TwnLctnNm", skip_serializing_if = "Option::is_none") )]
	pub twn_lctn_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DstrctNm", skip_serializing_if = "Option::is_none") )]
	pub dstrct_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrySubDvsn", skip_serializing_if = "Option::is_none") )]
	pub ctry_sub_dvsn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctry", skip_serializing_if = "Option::is_none") )]
	pub ctry: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AdrLine", skip_serializing_if = "Option::is_none") )]
	pub adr_line: Option<Vec<String>>,
}

impl PostalAddress24 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.adr_tp { val.validate()? }
		if let Some(ref val) = self.dept {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "dept is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "dept exceeds the maximum length of 70".to_string()));
			}
		}
		if let Some(ref val) = self.sub_dept {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "sub_dept is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "sub_dept exceeds the maximum length of 70".to_string()));
			}
		}
		if let Some(ref val) = self.strt_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "strt_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "strt_nm exceeds the maximum length of 70".to_string()));
			}
		}
		if let Some(ref val) = self.bldg_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "bldg_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 16 {
				return Err(ValidationError::new(1002, "bldg_nb exceeds the maximum length of 16".to_string()));
			}
		}
		if let Some(ref val) = self.bldg_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "bldg_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "bldg_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.flr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "flr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "flr exceeds the maximum length of 70".to_string()));
			}
		}
		if let Some(ref val) = self.pst_bx {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pst_bx is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 16 {
				return Err(ValidationError::new(1002, "pst_bx exceeds the maximum length of 16".to_string()));
			}
		}
		if let Some(ref val) = self.room {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "room is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "room exceeds the maximum length of 70".to_string()));
			}
		}
		if let Some(ref val) = self.pst_cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pst_cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 16 {
				return Err(ValidationError::new(1002, "pst_cd exceeds the maximum length of 16".to_string()));
			}
		}
		if let Some(ref val) = self.twn_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "twn_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "twn_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.twn_lctn_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "twn_lctn_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "twn_lctn_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.dstrct_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "dstrct_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "dstrct_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.ctry_sub_dvsn {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ctry_sub_dvsn is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "ctry_sub_dvsn exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.ctry {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry does not match the required pattern".to_string()));
			}
		}
		if let Some(ref vec) = self.adr_line {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "adr_line is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 70 {
					return Err(ValidationError::new(1002, "adr_line exceeds the maximum length of 70".to_string()));
				}
			}
		}
		Ok(())
	}
}


// PostalAddress27 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PostalAddress27 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AdrTp", skip_serializing_if = "Option::is_none") )]
	pub adr_tp: Option<AddressType3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CareOf", skip_serializing_if = "Option::is_none") )]
	pub care_of: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dept", skip_serializing_if = "Option::is_none") )]
	pub dept: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubDept", skip_serializing_if = "Option::is_none") )]
	pub sub_dept: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StrtNm", skip_serializing_if = "Option::is_none") )]
	pub strt_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BldgNb", skip_serializing_if = "Option::is_none") )]
	pub bldg_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BldgNm", skip_serializing_if = "Option::is_none") )]
	pub bldg_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Flr", skip_serializing_if = "Option::is_none") )]
	pub flr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnitNb", skip_serializing_if = "Option::is_none") )]
	pub unit_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstBx", skip_serializing_if = "Option::is_none") )]
	pub pst_bx: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Room", skip_serializing_if = "Option::is_none") )]
	pub room: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstCd", skip_serializing_if = "Option::is_none") )]
	pub pst_cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TwnNm", skip_serializing_if = "Option::is_none") )]
	pub twn_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TwnLctnNm", skip_serializing_if = "Option::is_none") )]
	pub twn_lctn_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DstrctNm", skip_serializing_if = "Option::is_none") )]
	pub dstrct_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrySubDvsn", skip_serializing_if = "Option::is_none") )]
	pub ctry_sub_dvsn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctry", skip_serializing_if = "Option::is_none") )]
	pub ctry: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AdrLine", skip_serializing_if = "Option::is_none") )]
	pub adr_line: Option<Vec<String>>,
}

impl PostalAddress27 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.adr_tp { val.validate()? }
		if let Some(ref val) = self.care_of {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "care_of is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "care_of exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.dept {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "dept is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "dept exceeds the maximum length of 70".to_string()));
			}
		}
		if let Some(ref val) = self.sub_dept {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "sub_dept is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "sub_dept exceeds the maximum length of 70".to_string()));
			}
		}
		if let Some(ref val) = self.strt_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "strt_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "strt_nm exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.bldg_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "bldg_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 16 {
				return Err(ValidationError::new(1002, "bldg_nb exceeds the maximum length of 16".to_string()));
			}
		}
		if let Some(ref val) = self.bldg_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "bldg_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "bldg_nm exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.flr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "flr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "flr exceeds the maximum length of 70".to_string()));
			}
		}
		if let Some(ref val) = self.unit_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "unit_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 16 {
				return Err(ValidationError::new(1002, "unit_nb exceeds the maximum length of 16".to_string()));
			}
		}
		if let Some(ref val) = self.pst_bx {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pst_bx is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 16 {
				return Err(ValidationError::new(1002, "pst_bx exceeds the maximum length of 16".to_string()));
			}
		}
		if let Some(ref val) = self.room {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "room is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "room exceeds the maximum length of 70".to_string()));
			}
		}
		if let Some(ref val) = self.pst_cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pst_cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 16 {
				return Err(ValidationError::new(1002, "pst_cd exceeds the maximum length of 16".to_string()));
			}
		}
		if let Some(ref val) = self.twn_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "twn_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "twn_nm exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.twn_lctn_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "twn_lctn_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "twn_lctn_nm exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.dstrct_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "dstrct_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "dstrct_nm exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.ctry_sub_dvsn {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ctry_sub_dvsn is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "ctry_sub_dvsn exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.ctry {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry does not match the required pattern".to_string()));
			}
		}
		if let Some(ref vec) = self.adr_line {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "adr_line is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 70 {
					return Err(ValidationError::new(1002, "adr_line exceeds the maximum length of 70".to_string()));
				}
			}
		}
		Ok(())
	}
}


// PostalAddress28 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PostalAddress28 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AdrTp", skip_serializing_if = "Option::is_none") )]
	pub adr_tp: Option<AddressType3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CareOf", skip_serializing_if = "Option::is_none") )]
	pub care_of: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dept", skip_serializing_if = "Option::is_none") )]
	pub dept: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubDept", skip_serializing_if = "Option::is_none") )]
	pub sub_dept: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StrtNm", skip_serializing_if = "Option::is_none") )]
	pub strt_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BldgNb", skip_serializing_if = "Option::is_none") )]
	pub bldg_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BldgNm", skip_serializing_if = "Option::is_none") )]
	pub bldg_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Flr", skip_serializing_if = "Option::is_none") )]
	pub flr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnitNb", skip_serializing_if = "Option::is_none") )]
	pub unit_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstBx", skip_serializing_if = "Option::is_none") )]
	pub pst_bx: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Room", skip_serializing_if = "Option::is_none") )]
	pub room: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstCd", skip_serializing_if = "Option::is_none") )]
	pub pst_cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TwnNm", skip_serializing_if = "Option::is_none") )]
	pub twn_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TwnLctnNm", skip_serializing_if = "Option::is_none") )]
	pub twn_lctn_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DstrctNm", skip_serializing_if = "Option::is_none") )]
	pub dstrct_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrySubDvsn", skip_serializing_if = "Option::is_none") )]
	pub ctry_sub_dvsn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctry", skip_serializing_if = "Option::is_none") )]
	pub ctry: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AdrLine", skip_serializing_if = "Option::is_none") )]
	pub adr_line: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldFr", skip_serializing_if = "Option::is_none") )]
	pub vld_fr: Option<String>,
}

impl PostalAddress28 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.adr_tp { val.validate()? }
		if let Some(ref val) = self.care_of {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "care_of is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "care_of exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.dept {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "dept is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "dept exceeds the maximum length of 70".to_string()));
			}
		}
		if let Some(ref val) = self.sub_dept {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "sub_dept is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "sub_dept exceeds the maximum length of 70".to_string()));
			}
		}
		if let Some(ref val) = self.strt_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "strt_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "strt_nm exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.bldg_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "bldg_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 16 {
				return Err(ValidationError::new(1002, "bldg_nb exceeds the maximum length of 16".to_string()));
			}
		}
		if let Some(ref val) = self.bldg_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "bldg_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "bldg_nm exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.flr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "flr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "flr exceeds the maximum length of 70".to_string()));
			}
		}
		if let Some(ref val) = self.unit_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "unit_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 16 {
				return Err(ValidationError::new(1002, "unit_nb exceeds the maximum length of 16".to_string()));
			}
		}
		if let Some(ref val) = self.pst_bx {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pst_bx is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 16 {
				return Err(ValidationError::new(1002, "pst_bx exceeds the maximum length of 16".to_string()));
			}
		}
		if let Some(ref val) = self.room {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "room is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "room exceeds the maximum length of 70".to_string()));
			}
		}
		if let Some(ref val) = self.pst_cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pst_cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 16 {
				return Err(ValidationError::new(1002, "pst_cd exceeds the maximum length of 16".to_string()));
			}
		}
		if let Some(ref val) = self.twn_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "twn_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "twn_nm exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.twn_lctn_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "twn_lctn_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "twn_lctn_nm exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.dstrct_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "dstrct_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "dstrct_nm exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.ctry_sub_dvsn {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ctry_sub_dvsn is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "ctry_sub_dvsn exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.ctry {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry does not match the required pattern".to_string()));
			}
		}
		if let Some(ref vec) = self.adr_line {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "adr_line is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 70 {
					return Err(ValidationError::new(1002, "adr_line exceeds the maximum length of 70".to_string()));
				}
			}
		}
		Ok(())
	}
}


// PostalAddress3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PostalAddress3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AdrTp") )]
	pub adr_tp: AddressType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MlngInd") )]
	pub mlng_ind: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegnAdrInd") )]
	pub regn_adr_ind: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NmAndAdr") )]
	pub nm_and_adr: NameAndAddress4,
}

impl PostalAddress3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.adr_tp.validate()?;
		self.nm_and_adr.validate()?;
		Ok(())
	}
}


// PostalAddress6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PostalAddress6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AdrTp", skip_serializing_if = "Option::is_none") )]
	pub adr_tp: Option<AddressType2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dept", skip_serializing_if = "Option::is_none") )]
	pub dept: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubDept", skip_serializing_if = "Option::is_none") )]
	pub sub_dept: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StrtNm", skip_serializing_if = "Option::is_none") )]
	pub strt_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BldgNb", skip_serializing_if = "Option::is_none") )]
	pub bldg_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstCd", skip_serializing_if = "Option::is_none") )]
	pub pst_cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TwnNm", skip_serializing_if = "Option::is_none") )]
	pub twn_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrySubDvsn", skip_serializing_if = "Option::is_none") )]
	pub ctry_sub_dvsn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctry", skip_serializing_if = "Option::is_none") )]
	pub ctry: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AdrLine", skip_serializing_if = "Option::is_none") )]
	pub adr_line: Option<Vec<String>>,
}

impl PostalAddress6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.adr_tp { val.validate()? }
		if let Some(ref val) = self.dept {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "dept is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "dept exceeds the maximum length of 70".to_string()));
			}
		}
		if let Some(ref val) = self.sub_dept {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "sub_dept is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "sub_dept exceeds the maximum length of 70".to_string()));
			}
		}
		if let Some(ref val) = self.strt_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "strt_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "strt_nm exceeds the maximum length of 70".to_string()));
			}
		}
		if let Some(ref val) = self.bldg_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "bldg_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 16 {
				return Err(ValidationError::new(1002, "bldg_nb exceeds the maximum length of 16".to_string()));
			}
		}
		if let Some(ref val) = self.pst_cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pst_cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 16 {
				return Err(ValidationError::new(1002, "pst_cd exceeds the maximum length of 16".to_string()));
			}
		}
		if let Some(ref val) = self.twn_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "twn_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "twn_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.ctry_sub_dvsn {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ctry_sub_dvsn is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "ctry_sub_dvsn exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.ctry {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry does not match the required pattern".to_string()));
			}
		}
		if let Some(ref vec) = self.adr_line {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "adr_line is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 70 {
					return Err(ValidationError::new(1002, "adr_line exceeds the maximum length of 70".to_string()));
				}
			}
		}
		Ok(())
	}
}


// PostedMarginOrCollateral4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PostedMarginOrCollateral4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitlMrgnPstd", skip_serializing_if = "Option::is_none") )]
	pub initl_mrgn_pstd: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VartnMrgnPstd", skip_serializing_if = "Option::is_none") )]
	pub vartn_mrgn_pstd: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XcssCollPstd", skip_serializing_if = "Option::is_none") )]
	pub xcss_coll_pstd: Option<ActiveOrHistoricCurrencyAndAmount>,
}

impl PostedMarginOrCollateral4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.initl_mrgn_pstd { val.validate()? }
		if let Some(ref val) = self.vartn_mrgn_pstd { val.validate()? }
		if let Some(ref val) = self.xcss_coll_pstd { val.validate()? }
		Ok(())
	}
}


// PostedMarginOrCollateral6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PostedMarginOrCollateral6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitlMrgnPstdPreHrcut", skip_serializing_if = "Option::is_none") )]
	pub initl_mrgn_pstd_pre_hrcut: Option<ActiveOrHistoricCurrencyAnd20DecimalAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitlMrgnPstdPstHrcut", skip_serializing_if = "Option::is_none") )]
	pub initl_mrgn_pstd_pst_hrcut: Option<ActiveOrHistoricCurrencyAnd20DecimalAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VartnMrgnPstdPreHrcut", skip_serializing_if = "Option::is_none") )]
	pub vartn_mrgn_pstd_pre_hrcut: Option<ActiveOrHistoricCurrencyAnd20DecimalAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VartnMrgnPstdPstHrcut", skip_serializing_if = "Option::is_none") )]
	pub vartn_mrgn_pstd_pst_hrcut: Option<ActiveOrHistoricCurrencyAnd20DecimalAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XcssCollPstd", skip_serializing_if = "Option::is_none") )]
	pub xcss_coll_pstd: Option<ActiveOrHistoricCurrencyAnd20DecimalAmount>,
}

impl PostedMarginOrCollateral6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.initl_mrgn_pstd_pre_hrcut { val.validate()? }
		if let Some(ref val) = self.initl_mrgn_pstd_pst_hrcut { val.validate()? }
		if let Some(ref val) = self.vartn_mrgn_pstd_pre_hrcut { val.validate()? }
		if let Some(ref val) = self.vartn_mrgn_pstd_pst_hrcut { val.validate()? }
		if let Some(ref val) = self.xcss_coll_pstd { val.validate()? }
		Ok(())
	}
}


// PreferenceToIncome1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PreferenceToIncome1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ORDN") )]
	CodeORDN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PFRD") )]
	CodePFRD,
}

impl PreferenceToIncome1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PreferenceToIncome5Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PreferenceToIncome5Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<PreferenceToIncome1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl PreferenceToIncome5Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// PreferredContactMethod1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PreferredContactMethod1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "LETT") )]
	CodeLETT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MAIL") )]
	CodeMAIL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PHON") )]
	CodePHON,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FAXX") )]
	CodeFAXX,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CELL") )]
	CodeCELL,
}

impl PreferredContactMethod1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PreferredContactMethod2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PreferredContactMethod2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "MAIL") )]
	CodeMAIL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FAXX") )]
	CodeFAXX,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LETT") )]
	CodeLETT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CELL") )]
	CodeCELL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ONLI") )]
	CodeONLI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PHON") )]
	CodePHON,
}

impl PreferredContactMethod2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PresentmentType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PresentmentType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "FULL") )]
	CodeFULL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PAYD") )]
	CodePAYD,
}

impl PresentmentType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Price7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Price7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: YieldedOrValueType1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val") )]
	pub val: PriceRateOrAmount3Choice,
}

impl Price7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tp.validate()?;
		self.val.validate()?;
		Ok(())
	}
}


// Price8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Price8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValTp", skip_serializing_if = "Option::is_none") )]
	pub val_tp: Option<PriceValueType3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val") )]
	pub val: PriceRateOrAmount3Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PricTp", skip_serializing_if = "Option::is_none") )]
	pub pric_tp: Option<TypeOfPrice1Code>,
}

impl Price8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val_tp { val.validate()? }
		self.val.validate()?;
		if let Some(ref val) = self.pric_tp { val.validate()? }
		Ok(())
	}
}


// PriceData2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PriceData2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pric", skip_serializing_if = "Option::is_none") )]
	pub pric: Option<SecuritiesTransactionPrice17Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SchdlPrd", skip_serializing_if = "Option::is_none") )]
	pub schdl_prd: Option<Vec<Schedule1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnitOfMeasr", skip_serializing_if = "Option::is_none") )]
	pub unit_of_measr: Option<UnitOfMeasure8Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PricMltplr", skip_serializing_if = "Option::is_none") )]
	pub pric_mltplr: Option<f64>,
}

impl PriceData2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.pric { val.validate()? }
		if let Some(ref vec) = self.schdl_prd { for item in vec { item.validate()? } }
		if let Some(ref val) = self.unit_of_measr { val.validate()? }
		Ok(())
	}
}


// PriceMethod1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PriceMethod1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "FORW") )]
	CodeFORW,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HIST") )]
	CodeHIST,
}

impl PriceMethod1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PriceMetrics3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PriceMetrics3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rates", skip_serializing_if = "Option::is_none") )]
	pub rates: Option<Rates3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LndgFee", skip_serializing_if = "Option::is_none") )]
	pub lndg_fee: Option<f64>,
}

impl PriceMetrics3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rates { val.validate()? }
		Ok(())
	}
}


// PriceRateOrAmount3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PriceRateOrAmount3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rate", skip_serializing_if = "Option::is_none") )]
	pub rate: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<ActiveOrHistoricCurrencyAnd13DecimalAmount>,
}

impl PriceRateOrAmount3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.amt { val.validate()? }
		Ok(())
	}
}


// PriceReport3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PriceReport3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PricValtnDtls") )]
	pub pric_valtn_dtls: Vec<PriceValuation4>,
}

impl PriceReport3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		for item in &self.pric_valtn_dtls { item.validate()? }
		Ok(())
	}
}


// PriceReportFunction1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PriceReportFunction1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "REPL") )]
	CodeREPL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NEWP") )]
	CodeNEWP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PART") )]
	CodePART,
}

impl PriceReportFunction1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PriceStatus1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PriceStatus1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "PNDG") )]
	CodePNDG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NOAP") )]
	CodeNOAP,
}

impl PriceStatus1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PriceStatus2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PriceStatus2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "PNDG") )]
	CodePNDG,
}

impl PriceStatus2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PriceType2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PriceType2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Strd") )]
	pub strd: TypeOfPrice6Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
}

impl PriceType2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.strd.validate()?;
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 350".to_string()));
			}
		}
		Ok(())
	}
}


// PriceValuation4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PriceValuation4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValtnDtTm", skip_serializing_if = "Option::is_none") )]
	pub valtn_dt_tm: Option<DateAndDateTimeChoice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NAVDtTm") )]
	pub nav_dt_tm: DateAndDateTimeChoice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmDtls") )]
	pub fin_instrm_dtls: FinancialInstrument8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FndMgmtCpny", skip_serializing_if = "Option::is_none") )]
	pub fnd_mgmt_cpny: Option<PartyIdentification2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNAV", skip_serializing_if = "Option::is_none") )]
	pub ttl_nav: Option<Vec<ActiveOrHistoricCurrencyAndAmount>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlUnitsNb", skip_serializing_if = "Option::is_none") )]
	pub ttl_units_nb: Option<FinancialInstrumentQuantity1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NxtValtnDtTm", skip_serializing_if = "Option::is_none") )]
	pub nxt_valtn_dt_tm: Option<DateAndDateTimeChoice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsValtnDtTm", skip_serializing_if = "Option::is_none") )]
	pub prvs_valtn_dt_tm: Option<DateAndDateTimeChoice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValtnTp") )]
	pub valtn_tp: ValuationTiming1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValtnFrqcy", skip_serializing_if = "Option::is_none") )]
	pub valtn_frqcy: Option<EventFrequency1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OffclValtnInd") )]
	pub offcl_valtn_ind: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SspdInd") )]
	pub sspd_ind: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PricDtls", skip_serializing_if = "Option::is_none") )]
	pub pric_dtls: Option<Vec<UnitPrice15>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValtnSttstcs", skip_serializing_if = "Option::is_none") )]
	pub valtn_sttstcs: Option<Vec<ValuationStatistics3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrfrmncDtls", skip_serializing_if = "Option::is_none") )]
	pub prfrmnc_dtls: Option<PerformanceFactors1>,
}

impl PriceValuation4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.valtn_dt_tm { val.validate()? }
		self.nav_dt_tm.validate()?;
		self.fin_instrm_dtls.validate()?;
		if let Some(ref val) = self.fnd_mgmt_cpny { val.validate()? }
		if let Some(ref vec) = self.ttl_nav { for item in vec { item.validate()? } }
		if let Some(ref val) = self.ttl_units_nb { val.validate()? }
		if let Some(ref val) = self.nxt_valtn_dt_tm { val.validate()? }
		if let Some(ref val) = self.prvs_valtn_dt_tm { val.validate()? }
		self.valtn_tp.validate()?;
		if let Some(ref val) = self.valtn_frqcy { val.validate()? }
		if let Some(ref vec) = self.pric_dtls { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.valtn_sttstcs { for item in vec { item.validate()? } }
		if let Some(ref val) = self.prfrmnc_dtls { val.validate()? }
		Ok(())
	}
}


// PriceValue1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PriceValue1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveCurrencyAnd13DecimalAmount,
}

impl PriceValue1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.amt.validate()?;
		Ok(())
	}
}


// PriceValue5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PriceValue5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveOrHistoricCurrencyAnd13DecimalAmount,
}

impl PriceValue5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.amt.validate()?;
		Ok(())
	}
}


// PriceValueChange1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PriceValueChange1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<ActiveOrHistoricCurrencyAnd13DecimalAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AmtSgn", skip_serializing_if = "Option::is_none") )]
	pub amt_sgn: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rate", skip_serializing_if = "Option::is_none") )]
	pub rate: Option<f64>,
}

impl PriceValueChange1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.amt { val.validate()? }
		Ok(())
	}
}


// PriceValueType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PriceValueType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "DISC") )]
	CodeDISC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PREM") )]
	CodePREM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PARV") )]
	CodePARV,
}

impl PriceValueType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PriceValueType3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PriceValueType3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "DISC") )]
	CodeDISC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PREM") )]
	CodePREM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PARV") )]
	CodePARV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "YIEL") )]
	CodeYIEL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SPRE") )]
	CodeSPRE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PEUN") )]
	CodePEUN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ABSO") )]
	CodeABSO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TEDP") )]
	CodeTEDP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TEDY") )]
	CodeTEDY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FICT") )]
	CodeFICT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VACT") )]
	CodeVACT,
}

impl PriceValueType3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PrincipalAmount3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PrincipalAmount3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValDtAmt", skip_serializing_if = "Option::is_none") )]
	pub val_dt_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MtrtyDtAmt", skip_serializing_if = "Option::is_none") )]
	pub mtrty_dt_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
}

impl PrincipalAmount3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val_dt_amt { val.validate()? }
		if let Some(ref val) = self.mtrty_dt_amt { val.validate()? }
		Ok(())
	}
}


// Priority1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Priority1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<Priority5Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl Priority1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// Priority1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum Priority1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "HIGH") )]
	CodeHIGH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NORM") )]
	CodeNORM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LOWW") )]
	CodeLOWW,
}

impl Priority1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Priority2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum Priority2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "HIGH") )]
	CodeHIGH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NORM") )]
	CodeNORM,
}

impl Priority2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Priority3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum Priority3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "URGT") )]
	CodeURGT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HIGH") )]
	CodeHIGH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NORM") )]
	CodeNORM,
}

impl Priority3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Priority5Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum Priority5Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "HIGH") )]
	CodeHIGH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LOWW") )]
	CodeLOWW,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NORM") )]
	CodeNORM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "URGT") )]
	CodeURGT,
}

impl Priority5Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PriorityNumeric4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PriorityNumeric4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nmrc", skip_serializing_if = "Option::is_none") )]
	pub nmrc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl PriorityNumeric4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nmrc {
			let pattern = Regex::new("[0-9]{4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "nmrc does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// ProcessingCharacteristics10 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ProcessingCharacteristics10 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DealgCcyAccptd", skip_serializing_if = "Option::is_none") )]
	pub dealg_ccy_accptd: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RedAuthstn", skip_serializing_if = "Option::is_none") )]
	pub red_authstn: Option<Forms1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AmtInd", skip_serializing_if = "Option::is_none") )]
	pub amt_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnitsInd", skip_serializing_if = "Option::is_none") )]
	pub units_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rndg", skip_serializing_if = "Option::is_none") )]
	pub rndg: Option<RoundingDirection2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PctgInd", skip_serializing_if = "Option::is_none") )]
	pub pctg_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MainFndOrdrDskLctn", skip_serializing_if = "Option::is_none") )]
	pub main_fnd_ordr_dsk_lctn: Option<MainFundOrderDeskLocation1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DealgFrqcy", skip_serializing_if = "Option::is_none") )]
	pub dealg_frqcy: Option<EventFrequency5Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DealgFrqcyDesc", skip_serializing_if = "Option::is_none") )]
	pub dealg_frqcy_desc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DealgCutOffTm", skip_serializing_if = "Option::is_none") )]
	pub dealg_cut_off_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DealgCutOffTmFrame", skip_serializing_if = "Option::is_none") )]
	pub dealg_cut_off_tm_frame: Option<TimeFrame9>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DealConfTm", skip_serializing_if = "Option::is_none") )]
	pub deal_conf_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DealConfTmFrame", skip_serializing_if = "Option::is_none") )]
	pub deal_conf_tm_frame: Option<TimeFrame8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LtdPrd", skip_serializing_if = "Option::is_none") )]
	pub ltd_prd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmCycl", skip_serializing_if = "Option::is_none") )]
	pub sttlm_cycl: Option<TimeFrame8Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<Vec<AdditionalInformation15>>,
}

impl ProcessingCharacteristics10 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.dealg_ccy_accptd {
			for item in vec {
				let pattern = Regex::new("[A-Z]{3,3}").unwrap();
				if !pattern.is_match(&item) {
					return Err(ValidationError::new(1005, "dealg_ccy_accptd does not match the required pattern".to_string()));
				}
			}
		}
		if let Some(ref val) = self.red_authstn { val.validate()? }
		if let Some(ref val) = self.rndg { val.validate()? }
		if let Some(ref val) = self.main_fnd_ordr_dsk_lctn { val.validate()? }
		if let Some(ref val) = self.dealg_frqcy { val.validate()? }
		if let Some(ref val) = self.dealg_frqcy_desc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "dealg_frqcy_desc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "dealg_frqcy_desc exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.dealg_cut_off_tm_frame { val.validate()? }
		if let Some(ref val) = self.deal_conf_tm_frame { val.validate()? }
		if let Some(ref val) = self.ltd_prd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ltd_prd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "ltd_prd exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.sttlm_cycl { val.validate()? }
		if let Some(ref vec) = self.addtl_inf { for item in vec { item.validate()? } }
		Ok(())
	}
}


// ProcessingCharacteristics11 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ProcessingCharacteristics11 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DealgCcyAccptd", skip_serializing_if = "Option::is_none") )]
	pub dealg_ccy_accptd: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitlInvstmtAppl", skip_serializing_if = "Option::is_none") )]
	pub initl_invstmt_appl: Option<Forms1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SbsqntInvstmtAppl", skip_serializing_if = "Option::is_none") )]
	pub sbsqnt_invstmt_appl: Option<Forms1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AmtInd", skip_serializing_if = "Option::is_none") )]
	pub amt_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnitsInd", skip_serializing_if = "Option::is_none") )]
	pub units_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rndg", skip_serializing_if = "Option::is_none") )]
	pub rndg: Option<RoundingDirection2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MainFndOrdrDskLctn", skip_serializing_if = "Option::is_none") )]
	pub main_fnd_ordr_dsk_lctn: Option<MainFundOrderDeskLocation1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DealgFrqcy", skip_serializing_if = "Option::is_none") )]
	pub dealg_frqcy: Option<EventFrequency5Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DealgFrqcyDesc", skip_serializing_if = "Option::is_none") )]
	pub dealg_frqcy_desc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DealgCutOffTm", skip_serializing_if = "Option::is_none") )]
	pub dealg_cut_off_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DealgCutOffTmFrame", skip_serializing_if = "Option::is_none") )]
	pub dealg_cut_off_tm_frame: Option<TimeFrame9>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DealConfTm", skip_serializing_if = "Option::is_none") )]
	pub deal_conf_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DealConfTmFrame", skip_serializing_if = "Option::is_none") )]
	pub deal_conf_tm_frame: Option<TimeFrame11>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LtdPrd", skip_serializing_if = "Option::is_none") )]
	pub ltd_prd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmCycl", skip_serializing_if = "Option::is_none") )]
	pub sttlm_cycl: Option<TimeFrame7Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<Vec<AdditionalInformation15>>,
}

impl ProcessingCharacteristics11 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.dealg_ccy_accptd {
			for item in vec {
				let pattern = Regex::new("[A-Z]{3,3}").unwrap();
				if !pattern.is_match(&item) {
					return Err(ValidationError::new(1005, "dealg_ccy_accptd does not match the required pattern".to_string()));
				}
			}
		}
		if let Some(ref val) = self.initl_invstmt_appl { val.validate()? }
		if let Some(ref val) = self.sbsqnt_invstmt_appl { val.validate()? }
		if let Some(ref val) = self.rndg { val.validate()? }
		if let Some(ref val) = self.main_fnd_ordr_dsk_lctn { val.validate()? }
		if let Some(ref val) = self.dealg_frqcy { val.validate()? }
		if let Some(ref val) = self.dealg_frqcy_desc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "dealg_frqcy_desc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "dealg_frqcy_desc exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.dealg_cut_off_tm_frame { val.validate()? }
		if let Some(ref val) = self.deal_conf_tm_frame { val.validate()? }
		if let Some(ref val) = self.ltd_prd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ltd_prd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "ltd_prd exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.sttlm_cycl { val.validate()? }
		if let Some(ref vec) = self.addtl_inf { for item in vec { item.validate()? } }
		Ok(())
	}
}


// ProcessingCharacteristics12 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ProcessingCharacteristics12 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DealgCcyAccptd", skip_serializing_if = "Option::is_none") )]
	pub dealg_ccy_accptd: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RedAuthstn", skip_serializing_if = "Option::is_none") )]
	pub red_authstn: Option<Forms1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AmtInd", skip_serializing_if = "Option::is_none") )]
	pub amt_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnitsInd", skip_serializing_if = "Option::is_none") )]
	pub units_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rndg", skip_serializing_if = "Option::is_none") )]
	pub rndg: Option<RoundingDirection2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PctgInd", skip_serializing_if = "Option::is_none") )]
	pub pctg_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MainFndOrdrDskLctn", skip_serializing_if = "Option::is_none") )]
	pub main_fnd_ordr_dsk_lctn: Option<MainFundOrderDeskLocation1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DealgFrqcy", skip_serializing_if = "Option::is_none") )]
	pub dealg_frqcy: Option<EventFrequency5Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DealgFrqcyDesc", skip_serializing_if = "Option::is_none") )]
	pub dealg_frqcy_desc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DealgCutOffTm", skip_serializing_if = "Option::is_none") )]
	pub dealg_cut_off_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DealgCutOffTmFrame", skip_serializing_if = "Option::is_none") )]
	pub dealg_cut_off_tm_frame: Option<TimeFrame9>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DealConfTm", skip_serializing_if = "Option::is_none") )]
	pub deal_conf_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DealConfTmFrame", skip_serializing_if = "Option::is_none") )]
	pub deal_conf_tm_frame: Option<TimeFrame10>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LtdPrd", skip_serializing_if = "Option::is_none") )]
	pub ltd_prd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmCycl", skip_serializing_if = "Option::is_none") )]
	pub sttlm_cycl: Option<TimeFrame8Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<Vec<AdditionalInformation15>>,
}

impl ProcessingCharacteristics12 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.dealg_ccy_accptd {
			for item in vec {
				let pattern = Regex::new("[A-Z]{3,3}").unwrap();
				if !pattern.is_match(&item) {
					return Err(ValidationError::new(1005, "dealg_ccy_accptd does not match the required pattern".to_string()));
				}
			}
		}
		if let Some(ref val) = self.red_authstn { val.validate()? }
		if let Some(ref val) = self.rndg { val.validate()? }
		if let Some(ref val) = self.main_fnd_ordr_dsk_lctn { val.validate()? }
		if let Some(ref val) = self.dealg_frqcy { val.validate()? }
		if let Some(ref val) = self.dealg_frqcy_desc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "dealg_frqcy_desc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "dealg_frqcy_desc exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.dealg_cut_off_tm_frame { val.validate()? }
		if let Some(ref val) = self.deal_conf_tm_frame { val.validate()? }
		if let Some(ref val) = self.ltd_prd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ltd_prd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "ltd_prd exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.sttlm_cycl { val.validate()? }
		if let Some(ref vec) = self.addtl_inf { for item in vec { item.validate()? } }
		Ok(())
	}
}


// ProcessingCharacteristics9 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ProcessingCharacteristics9 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DealgCcyAccptd", skip_serializing_if = "Option::is_none") )]
	pub dealg_ccy_accptd: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SwtchAuthstn", skip_serializing_if = "Option::is_none") )]
	pub swtch_authstn: Option<Forms1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AmtInd", skip_serializing_if = "Option::is_none") )]
	pub amt_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnitsInd", skip_serializing_if = "Option::is_none") )]
	pub units_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rndg", skip_serializing_if = "Option::is_none") )]
	pub rndg: Option<RoundingDirection2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MainFndOrdrDskLctn", skip_serializing_if = "Option::is_none") )]
	pub main_fnd_ordr_dsk_lctn: Option<MainFundOrderDeskLocation1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DealgFrqcy", skip_serializing_if = "Option::is_none") )]
	pub dealg_frqcy: Option<EventFrequency5Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DealgFrqcyDesc", skip_serializing_if = "Option::is_none") )]
	pub dealg_frqcy_desc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DealgCutOffTm", skip_serializing_if = "Option::is_none") )]
	pub dealg_cut_off_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DealgCutOffTmFrame", skip_serializing_if = "Option::is_none") )]
	pub dealg_cut_off_tm_frame: Option<TimeFrame9>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DealConfTm", skip_serializing_if = "Option::is_none") )]
	pub deal_conf_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DealConfTmFrame", skip_serializing_if = "Option::is_none") )]
	pub deal_conf_tm_frame: Option<TimeFrame8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LtdPrd", skip_serializing_if = "Option::is_none") )]
	pub ltd_prd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmCycl", skip_serializing_if = "Option::is_none") )]
	pub sttlm_cycl: Option<TimeFrame8Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<Vec<AdditionalInformation15>>,
}

impl ProcessingCharacteristics9 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.dealg_ccy_accptd {
			for item in vec {
				let pattern = Regex::new("[A-Z]{3,3}").unwrap();
				if !pattern.is_match(&item) {
					return Err(ValidationError::new(1005, "dealg_ccy_accptd does not match the required pattern".to_string()));
				}
			}
		}
		if let Some(ref val) = self.swtch_authstn { val.validate()? }
		if let Some(ref val) = self.rndg { val.validate()? }
		if let Some(ref val) = self.main_fnd_ordr_dsk_lctn { val.validate()? }
		if let Some(ref val) = self.dealg_frqcy { val.validate()? }
		if let Some(ref val) = self.dealg_frqcy_desc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "dealg_frqcy_desc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "dealg_frqcy_desc exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.dealg_cut_off_tm_frame { val.validate()? }
		if let Some(ref val) = self.deal_conf_tm_frame { val.validate()? }
		if let Some(ref val) = self.ltd_prd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ltd_prd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "ltd_prd exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.sttlm_cycl { val.validate()? }
		if let Some(ref vec) = self.addtl_inf { for item in vec { item.validate()? } }
		Ok(())
	}
}


// ProcessingPosition3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ProcessingPosition3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "AFTE") )]
	CodeAFTE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WITH") )]
	CodeWITH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BEFO") )]
	CodeBEFO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INFO") )]
	CodeINFO,
}

impl ProcessingPosition3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ProcessingPosition7Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ProcessingPosition7Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<ProcessingPosition3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl ProcessingPosition7Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// ProcessingStatus43Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ProcessingStatus43Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rcvd", skip_serializing_if = "Option::is_none") )]
	pub rcvd: Option<ReceivedStatusReason1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Accptd", skip_serializing_if = "Option::is_none") )]
	pub accptd: Option<AcceptedStatusReason7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PdgPrcg", skip_serializing_if = "Option::is_none") )]
	pub pdg_prcg: Option<PendingProcessingStatusReason1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rjctd", skip_serializing_if = "Option::is_none") )]
	pub rjctd: Option<RejectedStatusReason12>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtrySts", skip_serializing_if = "Option::is_none") )]
	pub prtry_sts: Option<ProprietaryStatusAndReason5>,
}

impl ProcessingStatus43Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rcvd { val.validate()? }
		if let Some(ref val) = self.accptd { val.validate()? }
		if let Some(ref val) = self.pdg_prcg { val.validate()? }
		if let Some(ref val) = self.rjctd { val.validate()? }
		if let Some(ref val) = self.prtry_sts { val.validate()? }
		Ok(())
	}
}


// ProcessingStatus66Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ProcessingStatus66Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AckdAccptd", skip_serializing_if = "Option::is_none") )]
	pub ackd_accptd: Option<AcknowledgedAcceptedStatus21Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rpr", skip_serializing_if = "Option::is_none") )]
	pub rpr: Option<RejectionOrRepairStatus38Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Canc", skip_serializing_if = "Option::is_none") )]
	pub canc: Option<CancellationStatus14Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<ProprietaryStatusAndReason6>,
}

impl ProcessingStatus66Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ackd_accptd { val.validate()? }
		if let Some(ref val) = self.rpr { val.validate()? }
		if let Some(ref val) = self.canc { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// ProcessingStatus67Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ProcessingStatus67Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rjctd", skip_serializing_if = "Option::is_none") )]
	pub rjctd: Option<RejectionOrRepairStatus38Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rpr", skip_serializing_if = "Option::is_none") )]
	pub rpr: Option<RejectionOrRepairStatus38Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Canc", skip_serializing_if = "Option::is_none") )]
	pub canc: Option<CancellationStatus14Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AckdAccptd", skip_serializing_if = "Option::is_none") )]
	pub ackd_accptd: Option<AcknowledgedAcceptedStatus21Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<ProprietaryStatusAndReason6>,
}

impl ProcessingStatus67Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rjctd { val.validate()? }
		if let Some(ref val) = self.rpr { val.validate()? }
		if let Some(ref val) = self.canc { val.validate()? }
		if let Some(ref val) = self.ackd_accptd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// ProcessingStatus68Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ProcessingStatus68Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<TransactionProcessingStatus3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl ProcessingStatus68Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// ProcessingStatus69Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ProcessingStatus69Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PdgCxl", skip_serializing_if = "Option::is_none") )]
	pub pdg_cxl: Option<PendingStatus39Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rjctd", skip_serializing_if = "Option::is_none") )]
	pub rjctd: Option<RejectionOrRepairStatus39Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rpr", skip_serializing_if = "Option::is_none") )]
	pub rpr: Option<RejectionOrRepairStatus39Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AckdAccptd", skip_serializing_if = "Option::is_none") )]
	pub ackd_accptd: Option<AcknowledgedAcceptedStatus24Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<ProprietaryStatusAndReason6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dnd", skip_serializing_if = "Option::is_none") )]
	pub dnd: Option<DeniedStatus16Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Canc", skip_serializing_if = "Option::is_none") )]
	pub canc: Option<CancellationStatus15Choice>,
}

impl ProcessingStatus69Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.pdg_cxl { val.validate()? }
		if let Some(ref val) = self.rjctd { val.validate()? }
		if let Some(ref val) = self.rpr { val.validate()? }
		if let Some(ref val) = self.ackd_accptd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		if let Some(ref val) = self.dnd { val.validate()? }
		if let Some(ref val) = self.canc { val.validate()? }
		Ok(())
	}
}


// ProcessingStatus71Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ProcessingStatus71Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AckdAccptd", skip_serializing_if = "Option::is_none") )]
	pub ackd_accptd: Option<AcknowledgedAcceptedStatus21Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pdg", skip_serializing_if = "Option::is_none") )]
	pub pdg: Option<PendingStatus38Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rjctd", skip_serializing_if = "Option::is_none") )]
	pub rjctd: Option<RejectionOrRepairStatus40Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rpr", skip_serializing_if = "Option::is_none") )]
	pub rpr: Option<RejectionOrRepairStatus39Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dnd", skip_serializing_if = "Option::is_none") )]
	pub dnd: Option<DeniedStatus16Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cmpltd", skip_serializing_if = "Option::is_none") )]
	pub cmpltd: Option<ProprietaryReason4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<ProprietaryStatusAndReason6>,
}

impl ProcessingStatus71Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ackd_accptd { val.validate()? }
		if let Some(ref val) = self.pdg { val.validate()? }
		if let Some(ref val) = self.rjctd { val.validate()? }
		if let Some(ref val) = self.rpr { val.validate()? }
		if let Some(ref val) = self.dnd { val.validate()? }
		if let Some(ref val) = self.cmpltd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// ProcessingStatus72Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ProcessingStatus72Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AckdAccptd", skip_serializing_if = "Option::is_none") )]
	pub ackd_accptd: Option<Reason4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PdgPrcg", skip_serializing_if = "Option::is_none") )]
	pub pdg_prcg: Option<Reason18Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rjctd", skip_serializing_if = "Option::is_none") )]
	pub rjctd: Option<Reason18Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cmpltd", skip_serializing_if = "Option::is_none") )]
	pub cmpltd: Option<Reason4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<ProprietaryStatusAndReason6>,
}

impl ProcessingStatus72Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ackd_accptd { val.validate()? }
		if let Some(ref val) = self.pdg_prcg { val.validate()? }
		if let Some(ref val) = self.rjctd { val.validate()? }
		if let Some(ref val) = self.cmpltd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// ProcessingType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ProcessingType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<ProcessingType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl ProcessingType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// ProcessingType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ProcessingType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "RJCT") )]
	CodeRJCT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CVHD") )]
	CodeCVHD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RSVT") )]
	CodeRSVT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BLCK") )]
	CodeBLCK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EARM") )]
	CodeEARM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EFAC") )]
	CodeEFAC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DLVR") )]
	CodeDLVR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "COLD") )]
	CodeCOLD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CSDB") )]
	CodeCSDB,
}

impl ProcessingType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Product1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Product1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Deriv", skip_serializing_if = "Option::is_none") )]
	pub deriv: Option<Derivative3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctiesFincgTx", skip_serializing_if = "Option::is_none") )]
	pub scties_fincg_tx: Option<RepurchaseAgreement3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Scty", skip_serializing_if = "Option::is_none") )]
	pub scty: Option<FinancialInstrument59>,
}

impl Product1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.deriv { val.validate()? }
		if let Some(ref val) = self.scties_fincg_tx { val.validate()? }
		if let Some(ref val) = self.scty { val.validate()? }
		Ok(())
	}
}


// Product2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Product2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PdctCd") )]
	pub pdct_cd: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnitOfMeasr", skip_serializing_if = "Option::is_none") )]
	pub unit_of_measr: Option<UnitOfMeasure1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PdctQty", skip_serializing_if = "Option::is_none") )]
	pub pdct_qty: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnitPric", skip_serializing_if = "Option::is_none") )]
	pub unit_pric: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PdctAmt", skip_serializing_if = "Option::is_none") )]
	pub pdct_amt: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxTp", skip_serializing_if = "Option::is_none") )]
	pub tax_tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlPdctInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_pdct_inf: Option<String>,
}

impl Product2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.pdct_cd.chars().count() < 1 {
			return Err(ValidationError::new(1001, "pdct_cd is shorter than the minimum length of 1".to_string()));
		}
		if self.pdct_cd.chars().count() > 70 {
			return Err(ValidationError::new(1002, "pdct_cd exceeds the maximum length of 70".to_string()));
		}
		if let Some(ref val) = self.unit_of_measr { val.validate()? }
		if let Some(ref val) = self.tax_tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tax_tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tax_tp exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.addtl_pdct_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_pdct_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "addtl_pdct_inf exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// ProductClassification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ProductClassification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AsstClss") )]
	pub asst_clss: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BasePdct", skip_serializing_if = "Option::is_none") )]
	pub base_pdct: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubPdct", skip_serializing_if = "Option::is_none") )]
	pub sub_pdct: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubCmmdty", skip_serializing_if = "Option::is_none") )]
	pub sub_cmmdty: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxTp", skip_serializing_if = "Option::is_none") )]
	pub tx_tp: Option<String>,
}

impl ProductClassification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.asst_clss.chars().count() < 1 {
			return Err(ValidationError::new(1001, "asst_clss is shorter than the minimum length of 1".to_string()));
		}
		if self.asst_clss.chars().count() > 35 {
			return Err(ValidationError::new(1002, "asst_clss exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.base_pdct {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "base_pdct is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "base_pdct exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.sub_pdct {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "sub_pdct is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "sub_pdct exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.sub_cmmdty {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "sub_cmmdty is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "sub_cmmdty exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.tx_tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tx_tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tx_tp exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// ProductClassificationCriteria1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ProductClassificationCriteria1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClssfctnFinInstrm", skip_serializing_if = "Option::is_none") )]
	pub clssfctn_fin_instrm: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnqPdctIdr", skip_serializing_if = "Option::is_none") )]
	pub unq_pdct_idr: Option<Vec<String>>,
}

impl ProductClassificationCriteria1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.clssfctn_fin_instrm {
			for item in vec {
				let pattern = Regex::new("[A-Z]{6,6}").unwrap();
				if !pattern.is_match(&item) {
					return Err(ValidationError::new(1005, "clssfctn_fin_instrm does not match the required pattern".to_string()));
				}
			}
		}
		if let Some(ref vec) = self.unq_pdct_idr {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "unq_pdct_idr is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 52 {
					return Err(ValidationError::new(1002, "unq_pdct_idr exceeds the maximum length of 52".to_string()));
				}
			}
		}
		Ok(())
	}
}


// ProductStructure1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ProductStructure1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<ProductStructure1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl ProductStructure1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// ProductStructure1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ProductStructure1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "BOND") )]
	CodeBOND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NUMM") )]
	CodeNUMM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UCMM") )]
	CodeUCMM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EXTC") )]
	CodeEXTC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UCIT") )]
	CodeUCIT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SSEC") )]
	CodeSSEC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SFUN") )]
	CodeSFUN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NUCI") )]
	CodeNUCI,
}

impl ProductStructure1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ProductType4Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ProductType4Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CRDT") )]
	CodeCRDT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CURR") )]
	CodeCURR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EQUI") )]
	CodeEQUI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INTR") )]
	CodeINTR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "COMM") )]
	CodeCOMM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
}

impl ProductType4Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ProductType6Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ProductType6Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "BOND") )]
	CodeBOND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CASH") )]
	CodeCASH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EQUI") )]
	CodeEQUI,
}

impl ProductType6Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ProductType7Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ProductType7Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "SVGN") )]
	CodeSVGN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EQUI") )]
	CodeEQUI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
}

impl ProductType7Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ProfileType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ProfileType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<ProfileType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl ProfileType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// ProfileType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ProfileType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "HEDG") )]
	CodeHEDG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HFTR") )]
	CodeHFTR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MAKE") )]
	CodeMAKE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TREA") )]
	CodeTREA,
}

impl ProfileType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ProformaStatusReason1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ProformaStatusReason1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd") )]
	pub cd: ProformaStatusReason2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
}

impl ProformaStatusReason1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.cd.validate()?;
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 350".to_string()));
			}
		}
		Ok(())
	}
}


// ProformaStatusReason1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ProformaStatusReason1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NoSpcfdRsn", skip_serializing_if = "Option::is_none") )]
	pub no_spcfd_rsn: Option<NoReasonCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<Vec<ProformaStatusReason1>>,
}

impl ProformaStatusReason1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.no_spcfd_rsn { val.validate()? }
		if let Some(ref vec) = self.rsn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// ProformaStatusReason1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ProformaStatusReason1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "MODI") )]
	CodeMODI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RIGH") )]
	CodeRIGH,
}

impl ProformaStatusReason1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ProformaStatusReason2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ProformaStatusReason2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<ProformaStatusReason1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification36>,
}

impl ProformaStatusReason2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// ProprietaryAgent5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ProprietaryAgent5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Agt") )]
	pub agt: BranchAndFinancialInstitutionIdentification8,
}

impl ProprietaryAgent5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.tp.chars().count() < 1 {
			return Err(ValidationError::new(1001, "tp is shorter than the minimum length of 1".to_string()));
		}
		if self.tp.chars().count() > 35 {
			return Err(ValidationError::new(1002, "tp exceeds the maximum length of 35".to_string()));
		}
		self.agt.validate()?;
		Ok(())
	}
}


// ProprietaryBankTransactionCodeStructure1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ProprietaryBankTransactionCodeStructure1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd") )]
	pub cd: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issr", skip_serializing_if = "Option::is_none") )]
	pub issr: Option<String>,
}

impl ProprietaryBankTransactionCodeStructure1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.cd.chars().count() < 1 {
			return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
		}
		if self.cd.chars().count() > 35 {
			return Err(ValidationError::new(1002, "cd exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.issr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "issr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "issr exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// ProprietaryData6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ProprietaryData6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Any") )]
	pub any: SkipPayload,
}

impl ProprietaryData6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.any.validate()?;
		Ok(())
	}
}


// ProprietaryData7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ProprietaryData7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Data") )]
	pub data: ProprietaryData6,
}

impl ProprietaryData7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.tp.chars().count() < 1 {
			return Err(ValidationError::new(1001, "tp is shorter than the minimum length of 1".to_string()));
		}
		if self.tp.chars().count() > 35 {
			return Err(ValidationError::new(1002, "tp exceeds the maximum length of 35".to_string()));
		}
		self.data.validate()?;
		Ok(())
	}
}


// ProprietaryDate3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ProprietaryDate3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dt") )]
	pub dt: DateAndDateTime2Choice,
}

impl ProprietaryDate3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.tp.chars().count() < 1 {
			return Err(ValidationError::new(1001, "tp is shorter than the minimum length of 1".to_string()));
		}
		if self.tp.chars().count() > 35 {
			return Err(ValidationError::new(1002, "tp exceeds the maximum length of 35".to_string()));
		}
		self.dt.validate()?;
		Ok(())
	}
}


// ProprietaryParty6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ProprietaryParty6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pty") )]
	pub pty: Party50Choice,
}

impl ProprietaryParty6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.tp.chars().count() < 1 {
			return Err(ValidationError::new(1001, "tp is shorter than the minimum length of 1".to_string()));
		}
		if self.tp.chars().count() > 35 {
			return Err(ValidationError::new(1002, "tp exceeds the maximum length of 35".to_string()));
		}
		self.pty.validate()?;
		Ok(())
	}
}


// ProprietaryPrice2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ProprietaryPrice2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pric") )]
	pub pric: ActiveOrHistoricCurrencyAndAmount,
}

impl ProprietaryPrice2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.tp.chars().count() < 1 {
			return Err(ValidationError::new(1001, "tp is shorter than the minimum length of 1".to_string()));
		}
		if self.tp.chars().count() > 35 {
			return Err(ValidationError::new(1002, "tp exceeds the maximum length of 35".to_string()));
		}
		self.pric.validate()?;
		Ok(())
	}
}


// ProprietaryQuantity1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ProprietaryQuantity1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Qty") )]
	pub qty: String,
}

impl ProprietaryQuantity1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.tp.chars().count() < 1 {
			return Err(ValidationError::new(1001, "tp is shorter than the minimum length of 1".to_string()));
		}
		if self.tp.chars().count() > 35 {
			return Err(ValidationError::new(1002, "tp exceeds the maximum length of 35".to_string()));
		}
		if self.qty.chars().count() < 1 {
			return Err(ValidationError::new(1001, "qty is shorter than the minimum length of 1".to_string()));
		}
		if self.qty.chars().count() > 35 {
			return Err(ValidationError::new(1002, "qty exceeds the maximum length of 35".to_string()));
		}
		Ok(())
	}
}


// ProprietaryReason1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ProprietaryReason1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NoSpcfdRsn", skip_serializing_if = "Option::is_none") )]
	pub no_spcfd_rsn: Option<NoReasonCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<Vec<GenericIdentification36>>,
}

impl ProprietaryReason1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.no_spcfd_rsn { val.validate()? }
		if let Some(ref vec) = self.rsn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// ProprietaryReason4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ProprietaryReason4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<GenericIdentification30>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlRsnInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_rsn_inf: Option<String>,
}

impl ProprietaryReason4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rsn { val.validate()? }
		if let Some(ref val) = self.addtl_rsn_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_rsn_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 210 {
				return Err(ValidationError::new(1002, "addtl_rsn_inf exceeds the maximum length of 210".to_string()));
			}
		}
		Ok(())
	}
}


// ProprietaryReference1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ProprietaryReference1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ref") )]
	pub ref_attr: String,
}

impl ProprietaryReference1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.tp.chars().count() < 1 {
			return Err(ValidationError::new(1001, "tp is shorter than the minimum length of 1".to_string()));
		}
		if self.tp.chars().count() > 35 {
			return Err(ValidationError::new(1002, "tp exceeds the maximum length of 35".to_string()));
		}
		if self.ref_attr.chars().count() < 1 {
			return Err(ValidationError::new(1001, "ref_attr is shorter than the minimum length of 1".to_string()));
		}
		if self.ref_attr.chars().count() > 35 {
			return Err(ValidationError::new(1002, "ref_attr exceeds the maximum length of 35".to_string()));
		}
		Ok(())
	}
}


// ProprietaryStatusAndReason5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ProprietaryStatusAndReason5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts") )]
	pub sts: GenericIdentification36,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn") )]
	pub rsn: ProprietaryReason1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlRsnInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_rsn_inf: Option<String>,
}

impl ProprietaryStatusAndReason5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.sts.validate()?;
		self.rsn.validate()?;
		if let Some(ref val) = self.addtl_rsn_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_rsn_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 210 {
				return Err(ValidationError::new(1002, "addtl_rsn_inf exceeds the maximum length of 210".to_string()));
			}
		}
		Ok(())
	}
}


// ProprietaryStatusAndReason6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ProprietaryStatusAndReason6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtrySts") )]
	pub prtry_sts: GenericIdentification30,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtryRsn", skip_serializing_if = "Option::is_none") )]
	pub prtry_rsn: Option<Vec<ProprietaryReason4>>,
}

impl ProprietaryStatusAndReason6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.prtry_sts.validate()?;
		if let Some(ref vec) = self.prtry_rsn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// ProprietaryStatusJustification2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ProprietaryStatusJustification2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtryStsRsn") )]
	pub prtry_sts_rsn: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn") )]
	pub rsn: String,
}

impl ProprietaryStatusJustification2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.prtry_sts_rsn.chars().count() < 1 {
			return Err(ValidationError::new(1001, "prtry_sts_rsn is shorter than the minimum length of 1".to_string()));
		}
		if self.prtry_sts_rsn.chars().count() > 4 {
			return Err(ValidationError::new(1002, "prtry_sts_rsn exceeds the maximum length of 4".to_string()));
		}
		let pattern = Regex::new("[a-zA-Z0-9]{1,4}").unwrap();
		if !pattern.is_match(&self.prtry_sts_rsn) {
			return Err(ValidationError::new(1005, "prtry_sts_rsn does not match the required pattern".to_string()));
		}
		if self.rsn.chars().count() < 1 {
			return Err(ValidationError::new(1001, "rsn is shorter than the minimum length of 1".to_string()));
		}
		if self.rsn.chars().count() > 256 {
			return Err(ValidationError::new(1002, "rsn exceeds the maximum length of 256".to_string()));
		}
		Ok(())
	}
}


// Provided1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum Provided1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "NPRO") )]
	CodeNPRO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PROV") )]
	CodePROV,
}

impl Provided1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ProxyAccountIdentification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ProxyAccountIdentification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<ProxyAccountType1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
}

impl ProxyAccountIdentification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tp { val.validate()? }
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 2048 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 2048".to_string()));
		}
		Ok(())
	}
}


// ProxyAccountType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ProxyAccountType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl ProxyAccountType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// Purpose2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Purpose2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl Purpose2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// Purpose3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Purpose3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctiesPurpCd", skip_serializing_if = "Option::is_none") )]
	pub scties_purp_cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification1>,
}

impl Purpose3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.scties_purp_cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "scties_purp_cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "scties_purp_cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// PurposeModification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PurposeModification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModCd", skip_serializing_if = "Option::is_none") )]
	pub mod_cd: Option<Modification1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Purp") )]
	pub purp: String,
}

impl PurposeModification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mod_cd { val.validate()? }
		if self.purp.chars().count() < 1 {
			return Err(ValidationError::new(1001, "purp is shorter than the minimum length of 1".to_string()));
		}
		if self.purp.chars().count() > 140 {
			return Err(ValidationError::new(1002, "purp exceeds the maximum length of 140".to_string()));
		}
		Ok(())
	}
}


// PutType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum PutType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "MAND") )]
	CodeMAND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OPTI") )]
	CodeOPTI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TWOS") )]
	CodeTWOS,
}

impl PutType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// PutType3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct PutType3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<PutType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl PutType3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// Quantity17 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Quantity17 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val") )]
	pub val: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnitOfMeasr") )]
	pub unit_of_measr: UnitOfMeasure11Code,
}

impl Quantity17 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.unit_of_measr.validate()?;
		Ok(())
	}
}


// Quantity47Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Quantity47Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Qty", skip_serializing_if = "Option::is_none") )]
	pub qty: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Desc", skip_serializing_if = "Option::is_none") )]
	pub desc: Option<String>,
}

impl Quantity47Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.desc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "desc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 52 {
				return Err(ValidationError::new(1002, "desc exceeds the maximum length of 52".to_string()));
			}
		}
		Ok(())
	}
}


// QuantityNominalValue2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct QuantityNominalValue2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Qty", skip_serializing_if = "Option::is_none") )]
	pub qty: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NmnlVal", skip_serializing_if = "Option::is_none") )]
	pub nmnl_val: Option<AmountAndDirection53>,
}

impl QuantityNominalValue2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nmnl_val { val.validate()? }
		Ok(())
	}
}


// QuantityOrTerm1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct QuantityOrTerm1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SchdlPrd", skip_serializing_if = "Option::is_none") )]
	pub schdl_prd: Option<Vec<Schedule10>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Term", skip_serializing_if = "Option::is_none") )]
	pub term: Option<QuantityTerm1>,
}

impl QuantityOrTerm1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.schdl_prd { for item in vec { item.validate()? } }
		if let Some(ref val) = self.term { val.validate()? }
		Ok(())
	}
}


// QuantityTerm1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct QuantityTerm1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Qty", skip_serializing_if = "Option::is_none") )]
	pub qty: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnitOfMeasr", skip_serializing_if = "Option::is_none") )]
	pub unit_of_measr: Option<UnitOfMeasure8Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val", skip_serializing_if = "Option::is_none") )]
	pub val: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TmUnit", skip_serializing_if = "Option::is_none") )]
	pub tm_unit: Option<Frequency19Code>,
}

impl QuantityTerm1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.unit_of_measr { val.validate()? }
		if let Some(ref val) = self.tm_unit { val.validate()? }
		Ok(())
	}
}


// QuantityType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct QuantityType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<OrderQuantityType2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl QuantityType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// QueryType2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum QueryType2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ALLL") )]
	CodeALLL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CHNG") )]
	CodeCHNG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MODF") )]
	CodeMODF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DELD") )]
	CodeDELD,
}

impl QueryType2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// QueryType3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum QueryType3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ALLL") )]
	CodeALLL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CHNG") )]
	CodeCHNG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MODF") )]
	CodeMODF,
}

impl QueryType3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// QueueTransactionIdentification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct QueueTransactionIdentification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "QId") )]
	pub q_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PosInQ") )]
	pub pos_in_q: String,
}

impl QueueTransactionIdentification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.q_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "q_id is shorter than the minimum length of 1".to_string()));
		}
		if self.q_id.chars().count() > 16 {
			return Err(ValidationError::new(1002, "q_id exceeds the maximum length of 16".to_string()));
		}
		if self.pos_in_q.chars().count() < 1 {
			return Err(ValidationError::new(1001, "pos_in_q is shorter than the minimum length of 1".to_string()));
		}
		if self.pos_in_q.chars().count() > 16 {
			return Err(ValidationError::new(1002, "pos_in_q exceeds the maximum length of 16".to_string()));
		}
		Ok(())
	}
}


// QuotationType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct QuotationType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<QuotationType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl QuotationType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// QuotationType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum QuotationType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACTU") )]
	CodeACTU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRCT") )]
	CodePRCT,
}

impl QuotationType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// RTPPartyIdentification2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RTPPartyIdentification2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstlAdr", skip_serializing_if = "Option::is_none") )]
	pub pstl_adr: Option<PostalAddress27>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<Party53Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtryOfRes", skip_serializing_if = "Option::is_none") )]
	pub ctry_of_res: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtctDtls", skip_serializing_if = "Option::is_none") )]
	pub ctct_dtls: Option<Contact13>,
}

impl RTPPartyIdentification2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.pstl_adr { val.validate()? }
		if let Some(ref val) = self.id { val.validate()? }
		if let Some(ref val) = self.ctry_of_res {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry_of_res does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.ctct_dtls { val.validate()? }
		Ok(())
	}
}


// Rank1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum Rank1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRIM") )]
	CodePRIM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SECO") )]
	CodeSECO,
}

impl Rank1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Rate4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Rate4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: RateType4Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldtyRg", skip_serializing_if = "Option::is_none") )]
	pub vldty_rg: Option<ActiveOrHistoricCurrencyAndAmountRange2>,
}

impl Rate4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tp.validate()?;
		if let Some(ref val) = self.vldty_rg { val.validate()? }
		Ok(())
	}
}


// RateAdjustment1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RateAdjustment1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rate") )]
	pub rate: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AdjstmntDt") )]
	pub adjstmnt_dt: String,
}

impl RateAdjustment1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// RateAndAmountFormat1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RateAndAmountFormat1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rate", skip_serializing_if = "Option::is_none") )]
	pub rate: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NotSpcfdRate", skip_serializing_if = "Option::is_none") )]
	pub not_spcfd_rate: Option<RateType12FormatChoice>,
}

impl RateAndAmountFormat1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.amt { val.validate()? }
		if let Some(ref val) = self.not_spcfd_rate { val.validate()? }
		Ok(())
	}
}


// RateBasis1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum RateBasis1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "DAYS") )]
	CodeDAYS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MNTH") )]
	CodeMNTH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WEEK") )]
	CodeWEEK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "YEAR") )]
	CodeYEAR,
}

impl RateBasis1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// RateOrAbsoluteValue1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RateOrAbsoluteValue1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RateVal", skip_serializing_if = "Option::is_none") )]
	pub rate_val: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AbsVal", skip_serializing_if = "Option::is_none") )]
	pub abs_val: Option<f64>,
}

impl RateOrAbsoluteValue1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// RateType12Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum RateType12Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "OPEN") )]
	CodeOPEN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UKWN") )]
	CodeUKWN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NILP") )]
	CodeNILP,
}

impl RateType12Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// RateType12FormatChoice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RateType12FormatChoice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<RateType12Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification13>,
}

impl RateType12FormatChoice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// RateType4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RateType4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pctg", skip_serializing_if = "Option::is_none") )]
	pub pctg: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<String>,
}

impl RateType4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.othr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "othr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "othr exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// Rates1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Rates1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Fxd", skip_serializing_if = "Option::is_none") )]
	pub fxd: Option<NoReasonCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Fltg", skip_serializing_if = "Option::is_none") )]
	pub fltg: Option<String>,
}

impl Rates1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.fxd { val.validate()? }
		if let Some(ref val) = self.fltg {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "fltg is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "fltg exceeds the maximum length of 4".to_string()));
			}
		}
		Ok(())
	}
}


// Rates3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Rates3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Fxd", skip_serializing_if = "Option::is_none") )]
	pub fxd: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Fltg", skip_serializing_if = "Option::is_none") )]
	pub fltg: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BuySellBck", skip_serializing_if = "Option::is_none") )]
	pub buy_sell_bck: Option<SecuritiesTransactionPrice18Choice>,
}

impl Rates3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.buy_sell_bck { val.validate()? }
		Ok(())
	}
}


// Reason18Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Reason18Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<Vec<ProprietaryReason4>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NoSpcfdRsn", skip_serializing_if = "Option::is_none") )]
	pub no_spcfd_rsn: Option<NoReasonCode>,
}

impl Reason18Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.rsn { for item in vec { item.validate()? } }
		if let Some(ref val) = self.no_spcfd_rsn { val.validate()? }
		Ok(())
	}
}


// Reason4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Reason4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<Vec<ProprietaryReason4>>,
}

impl Reason4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.rsn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// Receipt6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Receipt6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMsgId") )]
	pub orgnl_msg_id: OriginalMessageAndIssuer1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlPmtId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_pmt_id: Option<PaymentIdentification8Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqHdlg", skip_serializing_if = "Option::is_none") )]
	pub req_hdlg: Option<Vec<RequestHandling3>>,
}

impl Receipt6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.orgnl_msg_id.validate()?;
		if let Some(ref val) = self.orgnl_pmt_id { val.validate()? }
		if let Some(ref vec) = self.req_hdlg { for item in vec { item.validate()? } }
		Ok(())
	}
}


// ReceiptAcknowledgementReport2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReceiptAcknowledgementReport2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdRef") )]
	pub rltd_ref: MessageReference1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqHdlg") )]
	pub req_hdlg: RequestHandling2,
}

impl ReceiptAcknowledgementReport2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.rltd_ref.validate()?;
		self.req_hdlg.validate()?;
		Ok(())
	}
}


// ReceivedMarginOrCollateral4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReceivedMarginOrCollateral4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitlMrgnRcvd", skip_serializing_if = "Option::is_none") )]
	pub initl_mrgn_rcvd: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VartnMrgnRcvd", skip_serializing_if = "Option::is_none") )]
	pub vartn_mrgn_rcvd: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XcssCollRcvd", skip_serializing_if = "Option::is_none") )]
	pub xcss_coll_rcvd: Option<ActiveOrHistoricCurrencyAndAmount>,
}

impl ReceivedMarginOrCollateral4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.initl_mrgn_rcvd { val.validate()? }
		if let Some(ref val) = self.vartn_mrgn_rcvd { val.validate()? }
		if let Some(ref val) = self.xcss_coll_rcvd { val.validate()? }
		Ok(())
	}
}


// ReceivedMarginOrCollateral6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReceivedMarginOrCollateral6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitlMrgnRcvdPreHrcut", skip_serializing_if = "Option::is_none") )]
	pub initl_mrgn_rcvd_pre_hrcut: Option<ActiveOrHistoricCurrencyAnd20DecimalAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitlMrgnRcvdPstHrcut", skip_serializing_if = "Option::is_none") )]
	pub initl_mrgn_rcvd_pst_hrcut: Option<ActiveOrHistoricCurrencyAnd20DecimalAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VartnMrgnRcvdPreHrcut", skip_serializing_if = "Option::is_none") )]
	pub vartn_mrgn_rcvd_pre_hrcut: Option<ActiveOrHistoricCurrencyAnd20DecimalAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VartnMrgnRcvdPstHrcut", skip_serializing_if = "Option::is_none") )]
	pub vartn_mrgn_rcvd_pst_hrcut: Option<ActiveOrHistoricCurrencyAnd20DecimalAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XcssCollRcvd", skip_serializing_if = "Option::is_none") )]
	pub xcss_coll_rcvd: Option<ActiveOrHistoricCurrencyAnd20DecimalAmount>,
}

impl ReceivedMarginOrCollateral6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.initl_mrgn_rcvd_pre_hrcut { val.validate()? }
		if let Some(ref val) = self.initl_mrgn_rcvd_pst_hrcut { val.validate()? }
		if let Some(ref val) = self.vartn_mrgn_rcvd_pre_hrcut { val.validate()? }
		if let Some(ref val) = self.vartn_mrgn_rcvd_pst_hrcut { val.validate()? }
		if let Some(ref val) = self.xcss_coll_rcvd { val.validate()? }
		Ok(())
	}
}


// ReceivedReason1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReceivedReason1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NoSpcfdRsn", skip_serializing_if = "Option::is_none") )]
	pub no_spcfd_rsn: Option<NoReasonCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<ReceivedReason2Choice>,
}

impl ReceivedReason1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.no_spcfd_rsn { val.validate()? }
		if let Some(ref val) = self.rsn { val.validate()? }
		Ok(())
	}
}


// ReceivedReason2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReceivedReason2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification36>,
}

impl ReceivedReason2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// ReceivedStatusReason1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReceivedStatusReason1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn") )]
	pub rsn: ReceivedReason1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlRsnInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_rsn_inf: Option<String>,
}

impl ReceivedStatusReason1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.rsn.validate()?;
		if let Some(ref val) = self.addtl_rsn_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_rsn_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 210 {
				return Err(ValidationError::new(1002, "addtl_rsn_inf exceeds the maximum length of 210".to_string()));
			}
		}
		Ok(())
	}
}


// Reconciliation3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum Reconciliation3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "DPRW") )]
	CodeDPRW,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DPRV") )]
	CodeDPRV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DSMA") )]
	CodeDSMA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DSNM") )]
	CodeDSNM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NORE") )]
	CodeNORE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SSMA") )]
	CodeSSMA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SSPA") )]
	CodeSSPA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SPRW") )]
	CodeSPRW,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SPRV") )]
	CodeSPRV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SSUN") )]
	CodeSSUN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SSNE") )]
	CodeSSNE,
}

impl Reconciliation3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ReconciliationCategory4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReconciliationCategory4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rvvd") )]
	pub rvvd: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrthrMod") )]
	pub frthr_mod: bool,
}

impl ReconciliationCategory4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ReconciliationCategory5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReconciliationCategory5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgTp") )]
	pub rptg_tp: TradeRepositoryReportingType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pairg") )]
	pub pairg: PairingStatus1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rcncltn") )]
	pub rcncltn: ReconciliationStatus1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValtnRcncltn") )]
	pub valtn_rcncltn: ReconciliationStatus2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rvvd") )]
	pub rvvd: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrthrMod") )]
	pub frthr_mod: bool,
}

impl ReconciliationCategory5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.rptg_tp.validate()?;
		self.pairg.validate()?;
		self.rcncltn.validate()?;
		self.valtn_rcncltn.validate()?;
		Ok(())
	}
}


// ReconciliationCounterpartyPairStatistics7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReconciliationCounterpartyPairStatistics7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtyId") )]
	pub ctr_pty_id: CounterpartyData91,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNbOfTxs") )]
	pub ttl_nb_of_txs: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RcncltnRpt") )]
	pub rcncltn_rpt: Vec<ReconciliationReport15>,
}

impl ReconciliationCounterpartyPairStatistics7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.ctr_pty_id.validate()?;
		for item in &self.rcncltn_rpt { item.validate()? }
		Ok(())
	}
}


// ReconciliationFlag2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReconciliationFlag2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptTp", skip_serializing_if = "Option::is_none") )]
	pub rpt_tp: Option<TradeRepositoryReportingType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BothCtrPtiesRptg", skip_serializing_if = "Option::is_none") )]
	pub both_ctr_pties_rptg: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PairdSts", skip_serializing_if = "Option::is_none") )]
	pub paird_sts: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LnRcncltnSts", skip_serializing_if = "Option::is_none") )]
	pub ln_rcncltn_sts: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollRcncltnSts", skip_serializing_if = "Option::is_none") )]
	pub coll_rcncltn_sts: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModSts", skip_serializing_if = "Option::is_none") )]
	pub mod_sts: Option<bool>,
}

impl ReconciliationFlag2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rpt_tp { val.validate()? }
		Ok(())
	}
}


// ReconciliationMatchedStatus9Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReconciliationMatchedStatus9Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mtchd", skip_serializing_if = "Option::is_none") )]
	pub mtchd: Option<NoReasonCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NotMtchd", skip_serializing_if = "Option::is_none") )]
	pub not_mtchd: Option<ReconciliationResult10>,
}

impl ReconciliationMatchedStatus9Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mtchd { val.validate()? }
		if let Some(ref val) = self.not_mtchd { val.validate()? }
		Ok(())
	}
}


// ReconciliationReport15 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReconciliationReport15 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxId") )]
	pub tx_id: TradeTransactionIdentification24,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MtchgCrit") )]
	pub mtchg_crit: MatchingCriteria17,
}

impl ReconciliationReport15 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tx_id.validate()?;
		self.mtchg_crit.validate()?;
		Ok(())
	}
}


// ReconciliationReport8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReconciliationReport8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechRcrdId", skip_serializing_if = "Option::is_none") )]
	pub tech_rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxId") )]
	pub tx_id: TradeTransactionIdentification19,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Modfd") )]
	pub modfd: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RcncltnSts") )]
	pub rcncltn_sts: ReconciliationStatus8Choice,
}

impl ReconciliationReport8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tech_rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tech_rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "tech_rcrd_id exceeds the maximum length of 140".to_string()));
			}
		}
		self.tx_id.validate()?;
		self.rcncltn_sts.validate()?;
		Ok(())
	}
}


// ReconciliationResult10 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReconciliationResult10 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPty1") )]
	pub ctr_pty1: OrganisationIdentification15Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPty2") )]
	pub ctr_pty2: OrganisationIdentification15Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MtchgCrit") )]
	pub mtchg_crit: MatchingCriteria10,
}

impl ReconciliationResult10 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.ctr_pty1.validate()?;
		self.ctr_pty2.validate()?;
		self.mtchg_crit.validate()?;
		Ok(())
	}
}


// ReconciliationStatisticsPerCounterparty4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReconciliationStatisticsPerCounterparty4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RefDt") )]
	pub ref_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RcncltnCtgrs") )]
	pub rcncltn_ctgrs: ReportingRequirement3Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNbOfTxs", skip_serializing_if = "Option::is_none") )]
	pub ttl_nb_of_txs: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxDtls", skip_serializing_if = "Option::is_none") )]
	pub tx_dtls: Option<Vec<ReconciliationCounterpartyPairStatistics7>>,
}

impl ReconciliationStatisticsPerCounterparty4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.rcncltn_ctgrs.validate()?;
		if let Some(ref vec) = self.tx_dtls { for item in vec { item.validate()? } }
		Ok(())
	}
}


// ReconciliationStatus1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ReconciliationStatus1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "NREC") )]
	CodeNREC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RECO") )]
	CodeRECO,
}

impl ReconciliationStatus1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ReconciliationStatus2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ReconciliationStatus2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "NREC") )]
	CodeNREC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RECO") )]
	CodeRECO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NOAP") )]
	CodeNOAP,
}

impl ReconciliationStatus2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ReconciliationStatus8Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReconciliationStatus8Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NoRcncltnReqrd", skip_serializing_if = "Option::is_none") )]
	pub no_rcncltn_reqrd: Option<NoReasonCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgData", skip_serializing_if = "Option::is_none") )]
	pub rptg_data: Option<ReconciliationMatchedStatus9Choice>,
}

impl ReconciliationStatus8Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.no_rcncltn_reqrd { val.validate()? }
		if let Some(ref val) = self.rptg_data { val.validate()? }
		Ok(())
	}
}


// RecordTechnicalData2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RecordTechnicalData2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RctDtTm") )]
	pub rct_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CxlRsn") )]
	pub cxl_rsn: CancelledStatusReason15Code,
}

impl RecordTechnicalData2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.cxl_rsn.validate()?;
		Ok(())
	}
}


// RecordTechnicalData4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RecordTechnicalData4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "IncnsstncyInd", skip_serializing_if = "Option::is_none") )]
	pub incnsstncy_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LastUpd", skip_serializing_if = "Option::is_none") )]
	pub last_upd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubmissnDtTm", skip_serializing_if = "Option::is_none") )]
	pub submissn_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RlvntCmptntAuthrty", skip_serializing_if = "Option::is_none") )]
	pub rlvnt_cmptnt_authrty: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PblctnPrd", skip_serializing_if = "Option::is_none") )]
	pub pblctn_prd: Option<Period4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NvrPblshd", skip_serializing_if = "Option::is_none") )]
	pub nvr_pblshd: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RlvntTradgVn", skip_serializing_if = "Option::is_none") )]
	pub rlvnt_tradg_vn: Option<String>,
}

impl RecordTechnicalData4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rlvnt_cmptnt_authrty {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "rlvnt_cmptnt_authrty does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.pblctn_prd { val.validate()? }
		if let Some(ref val) = self.rlvnt_tradg_vn {
			let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "rlvnt_tradg_vn does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// RecordTechnicalData5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RecordTechnicalData5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RctDtTm") )]
	pub rct_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XchgRsn") )]
	pub xchg_rsn: Vec<String>,
}

impl RecordTechnicalData5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		for item in &self.xchg_rsn {
			if item.chars().count() < 1 {
				return Err(ValidationError::new(1001, "xchg_rsn is shorter than the minimum length of 1".to_string()));
			}
			if item.chars().count() > 4 {
				return Err(ValidationError::new(1002, "xchg_rsn exceeds the maximum length of 4".to_string()));
			}
		}
		Ok(())
	}
}


// ReferToFundOrderDesk1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ReferToFundOrderDesk1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "RFOD") )]
	CodeRFOD,
}

impl ReferToFundOrderDesk1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// References14 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct References14 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctOwnrTxId", skip_serializing_if = "Option::is_none") )]
	pub acct_ownr_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcrTxId", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktInfrstrctrTxId", skip_serializing_if = "Option::is_none") )]
	pub mkt_infrstrctr_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrcrTxId", skip_serializing_if = "Option::is_none") )]
	pub prcr_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PoolId", skip_serializing_if = "Option::is_none") )]
	pub pool_id: Option<String>,
}

impl References14 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.acct_ownr_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_ownr_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acct_ownr_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.acct_svcr_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_svcr_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acct_svcr_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.mkt_infrstrctr_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mkt_infrstrctr_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "mkt_infrstrctr_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.prcr_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prcr_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prcr_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.pool_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pool_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "pool_id exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// References3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct References3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: MessageIdentification1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqToBeCmpltdId") )]
	pub req_to_be_cmpltd_id: MessageIdentification1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrcId") )]
	pub prc_id: MessageIdentification1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqRsn") )]
	pub req_rsn: Vec<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AttchdDocNm", skip_serializing_if = "Option::is_none") )]
	pub attchd_doc_nm: Option<Vec<String>>,
}

impl References3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.msg_id.validate()?;
		self.req_to_be_cmpltd_id.validate()?;
		self.prc_id.validate()?;
		for item in &self.req_rsn {
			if item.chars().count() < 1 {
				return Err(ValidationError::new(1001, "req_rsn is shorter than the minimum length of 1".to_string()));
			}
			if item.chars().count() > 35 {
				return Err(ValidationError::new(1002, "req_rsn exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref vec) = self.attchd_doc_nm {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "attchd_doc_nm is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 70 {
					return Err(ValidationError::new(1002, "attchd_doc_nm exceeds the maximum length of 70".to_string()));
				}
			}
		}
		Ok(())
	}
}


// References34Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct References34Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctiesSttlmTxId", skip_serializing_if = "Option::is_none") )]
	pub scties_sttlm_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntraPosMvmntId", skip_serializing_if = "Option::is_none") )]
	pub intra_pos_mvmnt_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntraBalMvmntId", skip_serializing_if = "Option::is_none") )]
	pub intra_bal_mvmnt_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcrTxId", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktInfrstrctrTxId", skip_serializing_if = "Option::is_none") )]
	pub mkt_infrstrctr_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PoolId", skip_serializing_if = "Option::is_none") )]
	pub pool_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrTxId", skip_serializing_if = "Option::is_none") )]
	pub othr_tx_id: Option<String>,
}

impl References34Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.scties_sttlm_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "scties_sttlm_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "scties_sttlm_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.intra_pos_mvmnt_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "intra_pos_mvmnt_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "intra_pos_mvmnt_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.intra_bal_mvmnt_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "intra_bal_mvmnt_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "intra_bal_mvmnt_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.acct_svcr_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_svcr_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acct_svcr_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.mkt_infrstrctr_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mkt_infrstrctr_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "mkt_infrstrctr_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.pool_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pool_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "pool_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.othr_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "othr_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "othr_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// References36Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct References36Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctOwnrTxId", skip_serializing_if = "Option::is_none") )]
	pub acct_ownr_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcrTxId", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktInfrstrctrTxId", skip_serializing_if = "Option::is_none") )]
	pub mkt_infrstrctr_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrcrTxId", skip_serializing_if = "Option::is_none") )]
	pub prcr_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PoolId", skip_serializing_if = "Option::is_none") )]
	pub pool_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CorpActnEvtId", skip_serializing_if = "Option::is_none") )]
	pub corp_actn_evt_id: Option<String>,
}

impl References36Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.acct_ownr_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_ownr_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acct_ownr_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.acct_svcr_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_svcr_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acct_svcr_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.mkt_infrstrctr_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mkt_infrstrctr_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "mkt_infrstrctr_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.prcr_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prcr_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prcr_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.pool_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pool_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "pool_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.corp_actn_evt_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "corp_actn_evt_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "corp_actn_evt_id exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// References4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct References4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: MessageIdentification1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrcId") )]
	pub prc_id: MessageIdentification1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AttchdDocNm", skip_serializing_if = "Option::is_none") )]
	pub attchd_doc_nm: Option<Vec<String>>,
}

impl References4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.msg_id.validate()?;
		self.prc_id.validate()?;
		if let Some(ref vec) = self.attchd_doc_nm {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "attchd_doc_nm is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 70 {
					return Err(ValidationError::new(1002, "attchd_doc_nm exceeds the maximum length of 70".to_string()));
				}
			}
		}
		Ok(())
	}
}


// References5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct References5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqTp") )]
	pub req_tp: UseCases1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: MessageIdentification1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrcId") )]
	pub prc_id: MessageIdentification1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AckdMsgId", skip_serializing_if = "Option::is_none") )]
	pub ackd_msg_id: Option<Vec<MessageIdentification1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts", skip_serializing_if = "Option::is_none") )]
	pub sts: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AttchdDocNm", skip_serializing_if = "Option::is_none") )]
	pub attchd_doc_nm: Option<Vec<String>>,
}

impl References5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.req_tp.validate()?;
		self.msg_id.validate()?;
		self.prc_id.validate()?;
		if let Some(ref vec) = self.ackd_msg_id { for item in vec { item.validate()? } }
		if let Some(ref val) = self.sts {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "sts is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "sts exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref vec) = self.attchd_doc_nm {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "attchd_doc_nm is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 70 {
					return Err(ValidationError::new(1002, "attchd_doc_nm exceeds the maximum length of 70".to_string()));
				}
			}
		}
		Ok(())
	}
}


// References6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct References6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RjctdReqTp") )]
	pub rjctd_req_tp: UseCases1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RjctnRsn") )]
	pub rjctn_rsn: Vec<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RjctdReqId") )]
	pub rjctd_req_id: MessageIdentification1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: MessageIdentification1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrcId") )]
	pub prc_id: MessageIdentification1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AttchdDocNm", skip_serializing_if = "Option::is_none") )]
	pub attchd_doc_nm: Option<Vec<String>>,
}

impl References6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.rjctd_req_tp.validate()?;
		for item in &self.rjctn_rsn {
			if item.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rjctn_rsn is shorter than the minimum length of 1".to_string()));
			}
			if item.chars().count() > 350 {
				return Err(ValidationError::new(1002, "rjctn_rsn exceeds the maximum length of 350".to_string()));
			}
		}
		self.rjctd_req_id.validate()?;
		self.msg_id.validate()?;
		self.prc_id.validate()?;
		if let Some(ref vec) = self.attchd_doc_nm {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "attchd_doc_nm is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 70 {
					return Err(ValidationError::new(1002, "attchd_doc_nm exceeds the maximum length of 70".to_string()));
				}
			}
		}
		Ok(())
	}
}


// References74Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct References74Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctiesSttlmTxId", skip_serializing_if = "Option::is_none") )]
	pub scties_sttlm_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntraPosMvmntId", skip_serializing_if = "Option::is_none") )]
	pub intra_pos_mvmnt_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntraBalMvmntId", skip_serializing_if = "Option::is_none") )]
	pub intra_bal_mvmnt_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcrTxId", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktInfrstrctrTxId", skip_serializing_if = "Option::is_none") )]
	pub mkt_infrstrctr_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtyMktInfrstrctrTxId", skip_serializing_if = "Option::is_none") )]
	pub ctr_pty_mkt_infrstrctr_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PoolId", skip_serializing_if = "Option::is_none") )]
	pub pool_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CmonId", skip_serializing_if = "Option::is_none") )]
	pub cmon_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradId", skip_serializing_if = "Option::is_none") )]
	pub trad_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrTxId", skip_serializing_if = "Option::is_none") )]
	pub othr_tx_id: Option<String>,
}

impl References74Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.scties_sttlm_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "scties_sttlm_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "scties_sttlm_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.intra_pos_mvmnt_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "intra_pos_mvmnt_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "intra_pos_mvmnt_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.intra_bal_mvmnt_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "intra_bal_mvmnt_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "intra_bal_mvmnt_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.acct_svcr_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_svcr_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acct_svcr_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.mkt_infrstrctr_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mkt_infrstrctr_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "mkt_infrstrctr_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.ctr_pty_mkt_infrstrctr_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ctr_pty_mkt_infrstrctr_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "ctr_pty_mkt_infrstrctr_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.pool_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pool_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "pool_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.cmon_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cmon_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "cmon_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.trad_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "trad_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 52 {
				return Err(ValidationError::new(1002, "trad_id exceeds the maximum length of 52".to_string()));
			}
		}
		if let Some(ref val) = self.othr_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "othr_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "othr_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// Referred1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum Referred1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "REFR") )]
	CodeREFR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NRFR") )]
	CodeNRFR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UKNW") )]
	CodeUKNW,
}

impl Referred1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ReferredAgent3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReferredAgent3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rfrd") )]
	pub rfrd: Referred1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RfrdPlcmntAgt", skip_serializing_if = "Option::is_none") )]
	pub rfrd_plcmnt_agt: Option<PartyIdentification125Choice>,
}

impl ReferredAgent3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.rfrd.validate()?;
		if let Some(ref val) = self.rfrd_plcmnt_agt { val.validate()? }
		Ok(())
	}
}


// ReferredDocumentInformation7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReferredDocumentInformation7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<ReferredDocumentType4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nb", skip_serializing_if = "Option::is_none") )]
	pub nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdDt", skip_serializing_if = "Option::is_none") )]
	pub rltd_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LineDtls", skip_serializing_if = "Option::is_none") )]
	pub line_dtls: Option<Vec<DocumentLineInformation1>>,
}

impl ReferredDocumentInformation7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "nb exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref vec) = self.line_dtls { for item in vec { item.validate()? } }
		Ok(())
	}
}


// ReferredDocumentInformation8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReferredDocumentInformation8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<DocumentType1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nb", skip_serializing_if = "Option::is_none") )]
	pub nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdDt", skip_serializing_if = "Option::is_none") )]
	pub rltd_dt: Option<DateAndType1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LineDtls", skip_serializing_if = "Option::is_none") )]
	pub line_dtls: Option<Vec<DocumentLineInformation2>>,
}

impl ReferredDocumentInformation8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "nb exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.rltd_dt { val.validate()? }
		if let Some(ref vec) = self.line_dtls { for item in vec { item.validate()? } }
		Ok(())
	}
}


// ReferredDocumentType3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReferredDocumentType3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<DocumentType6Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl ReferredDocumentType3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// ReferredDocumentType4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReferredDocumentType4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdOrPrtry") )]
	pub cd_or_prtry: ReferredDocumentType3Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issr", skip_serializing_if = "Option::is_none") )]
	pub issr: Option<String>,
}

impl ReferredDocumentType4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.cd_or_prtry.validate()?;
		if let Some(ref val) = self.issr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "issr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "issr exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// ReferredMandateDocument2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReferredMandateDocument2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<DocumentType1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nb", skip_serializing_if = "Option::is_none") )]
	pub nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrRef", skip_serializing_if = "Option::is_none") )]
	pub cdtr_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdDt", skip_serializing_if = "Option::is_none") )]
	pub rltd_dt: Option<DateAndType1>,
}

impl ReferredMandateDocument2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "nb exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.cdtr_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cdtr_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "cdtr_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.rltd_dt { val.validate()? }
		Ok(())
	}
}


// RegisteredContract16 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RegisteredContract16 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctRegnAmdmntId") )]
	pub ctrct_regn_amdmnt_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgPty") )]
	pub rptg_pty: TradeParty6,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegnAgt") )]
	pub regn_agt: BranchAndFinancialInstitutionIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegdCtrctAmdmnt") )]
	pub regd_ctrct_amdmnt: Vec<RegisteredContract17>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl RegisteredContract16 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.ctrct_regn_amdmnt_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "ctrct_regn_amdmnt_id is shorter than the minimum length of 1".to_string()));
		}
		if self.ctrct_regn_amdmnt_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "ctrct_regn_amdmnt_id exceeds the maximum length of 35".to_string()));
		}
		self.rptg_pty.validate()?;
		self.regn_agt.validate()?;
		for item in &self.regd_ctrct_amdmnt { item.validate()? }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// RegisteredContract17 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RegisteredContract17 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegdCtrctAmdmntId") )]
	pub regd_ctrct_amdmnt_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlRegdCtrctId") )]
	pub orgnl_regd_ctrct_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prty") )]
	pub prty: Priority2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctrct") )]
	pub ctrct: UnderlyingContract4Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctBal", skip_serializing_if = "Option::is_none") )]
	pub ctrct_bal: Option<Vec<ContractBalance1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtSchdlTp", skip_serializing_if = "Option::is_none") )]
	pub pmt_schdl_tp: Option<PaymentScheduleType2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Attchmnt", skip_serializing_if = "Option::is_none") )]
	pub attchmnt: Option<Vec<DocumentGeneralInformation5>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl RegisteredContract17 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.regd_ctrct_amdmnt_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "regd_ctrct_amdmnt_id is shorter than the minimum length of 1".to_string()));
		}
		if self.regd_ctrct_amdmnt_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "regd_ctrct_amdmnt_id exceeds the maximum length of 35".to_string()));
		}
		if self.orgnl_regd_ctrct_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "orgnl_regd_ctrct_id is shorter than the minimum length of 1".to_string()));
		}
		if self.orgnl_regd_ctrct_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "orgnl_regd_ctrct_id exceeds the maximum length of 35".to_string()));
		}
		self.prty.validate()?;
		self.ctrct.validate()?;
		if let Some(ref vec) = self.ctrct_bal { for item in vec { item.validate()? } }
		if let Some(ref val) = self.pmt_schdl_tp { val.validate()? }
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 1025 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 1025".to_string()));
			}
		}
		if let Some(ref vec) = self.attchmnt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// RegisteredContract18 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RegisteredContract18 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlCtrctRegnReq", skip_serializing_if = "Option::is_none") )]
	pub orgnl_ctrct_regn_req: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IssrFI") )]
	pub issr_fi: BranchAndFinancialInstitutionIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctrct") )]
	pub ctrct: UnderlyingContract4Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctBal", skip_serializing_if = "Option::is_none") )]
	pub ctrct_bal: Option<Vec<ContractBalance1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtSchdlTp", skip_serializing_if = "Option::is_none") )]
	pub pmt_schdl_tp: Option<PaymentScheduleType2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegdCtrctId") )]
	pub regd_ctrct_id: DocumentIdentification29,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsRegdCtrctId", skip_serializing_if = "Option::is_none") )]
	pub prvs_regd_ctrct_id: Option<DocumentIdentification22>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegdCtrctJrnl", skip_serializing_if = "Option::is_none") )]
	pub regd_ctrct_jrnl: Option<Vec<RegisteredContractJournal3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amdmnt", skip_serializing_if = "Option::is_none") )]
	pub amdmnt: Option<Vec<RegisteredContractAmendment1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Submissn") )]
	pub submissn: RegisteredContractCommunication1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dlvry") )]
	pub dlvry: RegisteredContractCommunication1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LnPrncplAmt", skip_serializing_if = "Option::is_none") )]
	pub ln_prncpl_amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EstmtdDtInd") )]
	pub estmtd_dt_ind: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrCpnyLn") )]
	pub intr_cpny_ln: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
}

impl RegisteredContract18 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgnl_ctrct_regn_req {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_ctrct_regn_req is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_ctrct_regn_req exceeds the maximum length of 35".to_string()));
			}
		}
		self.issr_fi.validate()?;
		self.ctrct.validate()?;
		if let Some(ref vec) = self.ctrct_bal { for item in vec { item.validate()? } }
		if let Some(ref val) = self.pmt_schdl_tp { val.validate()? }
		self.regd_ctrct_id.validate()?;
		if let Some(ref val) = self.prvs_regd_ctrct_id { val.validate()? }
		if let Some(ref vec) = self.regd_ctrct_jrnl { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.amdmnt { for item in vec { item.validate()? } }
		self.submissn.validate()?;
		self.dlvry.validate()?;
		if let Some(ref val) = self.ln_prncpl_amt { val.validate()? }
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 1025 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 1025".to_string()));
			}
		}
		Ok(())
	}
}


// RegisteredContract19 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RegisteredContract19 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegdCtrctClsrId") )]
	pub regd_ctrct_clsr_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgPty") )]
	pub rptg_pty: TradeParty6,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegnAgt") )]
	pub regn_agt: BranchAndFinancialInstitutionIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlRegdCtrct") )]
	pub orgnl_regd_ctrct: DocumentIdentification29,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prty") )]
	pub prty: Priority2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClsrRsn") )]
	pub clsr_rsn: ContractClosureReason1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cssn", skip_serializing_if = "Option::is_none") )]
	pub cssn: Option<ContractCessionData2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Attchmnt", skip_serializing_if = "Option::is_none") )]
	pub attchmnt: Option<Vec<DocumentGeneralInformation5>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl RegisteredContract19 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.regd_ctrct_clsr_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "regd_ctrct_clsr_id is shorter than the minimum length of 1".to_string()));
		}
		if self.regd_ctrct_clsr_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "regd_ctrct_clsr_id exceeds the maximum length of 35".to_string()));
		}
		self.rptg_pty.validate()?;
		self.regn_agt.validate()?;
		self.orgnl_regd_ctrct.validate()?;
		self.prty.validate()?;
		self.clsr_rsn.validate()?;
		if let Some(ref val) = self.cssn { val.validate()? }
		if let Some(ref vec) = self.attchmnt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// RegisteredContract20 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RegisteredContract20 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlCtrctRegnReq", skip_serializing_if = "Option::is_none") )]
	pub orgnl_ctrct_regn_req: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgPty") )]
	pub rptg_pty: TradeParty6,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegnAgt") )]
	pub regn_agt: BranchAndFinancialInstitutionIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IssrFI") )]
	pub issr_fi: BranchAndFinancialInstitutionIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctrct") )]
	pub ctrct: UnderlyingContract4Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctBal", skip_serializing_if = "Option::is_none") )]
	pub ctrct_bal: Option<Vec<ContractBalance1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtSchdlTp", skip_serializing_if = "Option::is_none") )]
	pub pmt_schdl_tp: Option<PaymentScheduleType2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegdCtrctId") )]
	pub regd_ctrct_id: DocumentIdentification29,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsRegdCtrctId", skip_serializing_if = "Option::is_none") )]
	pub prvs_regd_ctrct_id: Option<DocumentIdentification22>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegdCtrctJrnl", skip_serializing_if = "Option::is_none") )]
	pub regd_ctrct_jrnl: Option<Vec<RegisteredContractJournal3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amdmnt", skip_serializing_if = "Option::is_none") )]
	pub amdmnt: Option<Vec<RegisteredContractAmendment1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Submissn") )]
	pub submissn: RegisteredContractCommunication1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dlvry") )]
	pub dlvry: RegisteredContractCommunication1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LnPrncplAmt", skip_serializing_if = "Option::is_none") )]
	pub ln_prncpl_amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EstmtdDtInd") )]
	pub estmtd_dt_ind: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrCpnyLn") )]
	pub intr_cpny_ln: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl RegisteredContract20 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgnl_ctrct_regn_req {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_ctrct_regn_req is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_ctrct_regn_req exceeds the maximum length of 35".to_string()));
			}
		}
		self.rptg_pty.validate()?;
		self.regn_agt.validate()?;
		self.issr_fi.validate()?;
		self.ctrct.validate()?;
		if let Some(ref vec) = self.ctrct_bal { for item in vec { item.validate()? } }
		if let Some(ref val) = self.pmt_schdl_tp { val.validate()? }
		self.regd_ctrct_id.validate()?;
		if let Some(ref val) = self.prvs_regd_ctrct_id { val.validate()? }
		if let Some(ref vec) = self.regd_ctrct_jrnl { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.amdmnt { for item in vec { item.validate()? } }
		self.submissn.validate()?;
		self.dlvry.validate()?;
		if let Some(ref val) = self.ln_prncpl_amt { val.validate()? }
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 1025 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 1025".to_string()));
			}
		}
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// RegisteredContractAmendment1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RegisteredContractAmendment1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AmdmntDt") )]
	pub amdmnt_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Doc") )]
	pub doc: DocumentIdentification28,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StartDt", skip_serializing_if = "Option::is_none") )]
	pub start_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AmdmntRsn", skip_serializing_if = "Option::is_none") )]
	pub amdmnt_rsn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
}

impl RegisteredContractAmendment1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.doc.validate()?;
		if let Some(ref val) = self.amdmnt_rsn {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "amdmnt_rsn is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "amdmnt_rsn exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 1025 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 1025".to_string()));
			}
		}
		Ok(())
	}
}


// RegisteredContractCommunication1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RegisteredContractCommunication1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mtd") )]
	pub mtd: CommunicationMethod4Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dt") )]
	pub dt: String,
}

impl RegisteredContractCommunication1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.mtd.validate()?;
		Ok(())
	}
}


// RegisteredContractJournal3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RegisteredContractJournal3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegnAgt") )]
	pub regn_agt: BranchAndFinancialInstitutionIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnqId", skip_serializing_if = "Option::is_none") )]
	pub unq_id: Option<DocumentIdentification28>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClsrDt") )]
	pub clsr_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClsrRsn") )]
	pub clsr_rsn: ContractClosureReason1Choice,
}

impl RegisteredContractJournal3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.regn_agt.validate()?;
		if let Some(ref val) = self.unq_id { val.validate()? }
		self.clsr_rsn.validate()?;
		Ok(())
	}
}


// RegisteredShareholderName1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RegisteredShareholderName1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "IndvPrsn", skip_serializing_if = "Option::is_none") )]
	pub indv_prsn: Option<IndividualPerson29>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Org", skip_serializing_if = "Option::is_none") )]
	pub org: Option<Organisation23>,
}

impl RegisteredShareholderName1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.indv_prsn { val.validate()? }
		if let Some(ref val) = self.org { val.validate()? }
		Ok(())
	}
}


// RegulatoryAuthority2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RegulatoryAuthority2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctry", skip_serializing_if = "Option::is_none") )]
	pub ctry: Option<String>,
}

impl RegulatoryAuthority2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.ctry {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// RegulatoryInformation1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RegulatoryInformation1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sctr", skip_serializing_if = "Option::is_none") )]
	pub sctr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Brnch", skip_serializing_if = "Option::is_none") )]
	pub brnch: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Grp", skip_serializing_if = "Option::is_none") )]
	pub grp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<String>,
}

impl RegulatoryInformation1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.sctr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "sctr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "sctr exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.brnch {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "brnch is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "brnch exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.grp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "grp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "grp exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.othr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "othr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "othr exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// RegulatoryReporting3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RegulatoryReporting3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtCdtRptgInd", skip_serializing_if = "Option::is_none") )]
	pub dbt_cdt_rptg_ind: Option<RegulatoryReportingType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Authrty", skip_serializing_if = "Option::is_none") )]
	pub authrty: Option<RegulatoryAuthority2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dtls", skip_serializing_if = "Option::is_none") )]
	pub dtls: Option<Vec<StructuredRegulatoryReporting3>>,
}

impl RegulatoryReporting3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.dbt_cdt_rptg_ind { val.validate()? }
		if let Some(ref val) = self.authrty { val.validate()? }
		if let Some(ref vec) = self.dtls { for item in vec { item.validate()? } }
		Ok(())
	}
}


// RegulatoryReportingNotification4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RegulatoryReportingNotification4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxNtfctnId") )]
	pub tx_ntfctn_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctOwnr") )]
	pub acct_ownr: PartyIdentification272,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcr") )]
	pub acct_svcr: BranchAndFinancialInstitutionIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxCert") )]
	pub tx_cert: Vec<TransactionCertificate4>,
}

impl RegulatoryReportingNotification4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.tx_ntfctn_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "tx_ntfctn_id is shorter than the minimum length of 1".to_string()));
		}
		if self.tx_ntfctn_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "tx_ntfctn_id exceeds the maximum length of 35".to_string()));
		}
		self.acct_ownr.validate()?;
		self.acct_svcr.validate()?;
		for item in &self.tx_cert { item.validate()? }
		Ok(())
	}
}


// RegulatoryReportingType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum RegulatoryReportingType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CRED") )]
	CodeCRED,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DEBT") )]
	CodeDEBT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BOTH") )]
	CodeBOTH,
}

impl RegulatoryReportingType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// RegulatoryTradingCapacity1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum RegulatoryTradingCapacity1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "MTCH") )]
	CodeMTCH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DEAL") )]
	CodeDEAL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AOTC") )]
	CodeAOTC,
}

impl RegulatoryTradingCapacity1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ReinvestedCashTypeAndAmount1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReinvestedCashTypeAndAmount1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: ReinvestmentType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RinvstdCshAmt") )]
	pub rinvstd_csh_amt: ActiveOrHistoricCurrencyAndAmount,
}

impl ReinvestedCashTypeAndAmount1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tp.validate()?;
		self.rinvstd_csh_amt.validate()?;
		Ok(())
	}
}


// ReinvestedCashTypeAndAmount2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReinvestedCashTypeAndAmount2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: ReinvestmentType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RinvstdCshCcy") )]
	pub rinvstd_csh_ccy: String,
}

impl ReinvestedCashTypeAndAmount2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tp.validate()?;
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.rinvstd_csh_ccy) {
			return Err(ValidationError::new(1005, "rinvstd_csh_ccy does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// Reinvestment4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Reinvestment4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmDtls") )]
	pub fin_instrm_dtls: FinancialInstrument87,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdNAVCcy", skip_serializing_if = "Option::is_none") )]
	pub reqd_nav_ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RinvstmtPctg") )]
	pub rinvstmt_pctg: f64,
}

impl Reinvestment4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.fin_instrm_dtls.validate()?;
		if let Some(ref val) = self.reqd_nav_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "reqd_nav_ccy does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// ReinvestmentType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ReinvestmentType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OCMP") )]
	CodeOCMP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MMFT") )]
	CodeMMFT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REPM") )]
	CodeREPM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SDPU") )]
	CodeSDPU,
}

impl ReinvestmentType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// RejectedReason16Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RejectedReason16Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<RejectedStatusReason6Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification36>,
}

impl RejectedReason16Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// RejectedReason7Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RejectedReason7Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification36>,
}

impl RejectedReason7Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// RejectedReason8Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RejectedReason8Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NoSpcfdRsn", skip_serializing_if = "Option::is_none") )]
	pub no_spcfd_rsn: Option<NoReasonCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<Vec<RejectedReason7Choice>>,
}

impl RejectedReason8Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.no_spcfd_rsn { val.validate()? }
		if let Some(ref vec) = self.rsn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// RejectedStatusReason12 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RejectedStatusReason12 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn") )]
	pub rsn: RejectedReason8Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlRsnInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_rsn_inf: Option<String>,
}

impl RejectedStatusReason12 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.rsn.validate()?;
		if let Some(ref val) = self.addtl_rsn_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_rsn_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 210 {
				return Err(ValidationError::new(1002, "addtl_rsn_inf exceeds the maximum length of 210".to_string()));
			}
		}
		Ok(())
	}
}


// RejectedStatusReason6Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum RejectedStatusReason6Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "SAFE") )]
	CodeSAFE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NSLA") )]
	CodeNSLA,
}

impl RejectedStatusReason6Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// RejectionAndRepairReason32Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RejectionAndRepairReason32Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<RejectionReason33Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl RejectionAndRepairReason32Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// RejectionAndRepairReason33Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RejectionAndRepairReason33Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<RejectionReason34Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl RejectionAndRepairReason33Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// RejectionAndRepairReason34Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RejectionAndRepairReason34Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<RejectionReason35Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl RejectionAndRepairReason34Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// RejectionOrRepairReason32 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RejectionOrRepairReason32 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<Vec<RejectionAndRepairReason32Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlRsnInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_rsn_inf: Option<String>,
}

impl RejectionOrRepairReason32 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.cd { for item in vec { item.validate()? } }
		if let Some(ref val) = self.addtl_rsn_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_rsn_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 210 {
				return Err(ValidationError::new(1002, "addtl_rsn_inf exceeds the maximum length of 210".to_string()));
			}
		}
		Ok(())
	}
}


// RejectionOrRepairReason33 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RejectionOrRepairReason33 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd") )]
	pub cd: RejectionAndRepairReason33Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlRsnInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_rsn_inf: Option<String>,
}

impl RejectionOrRepairReason33 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.cd.validate()?;
		if let Some(ref val) = self.addtl_rsn_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_rsn_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 210 {
				return Err(ValidationError::new(1002, "addtl_rsn_inf exceeds the maximum length of 210".to_string()));
			}
		}
		Ok(())
	}
}


// RejectionOrRepairReason34 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RejectionOrRepairReason34 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd") )]
	pub cd: RejectionAndRepairReason34Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlRsnInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_rsn_inf: Option<String>,
}

impl RejectionOrRepairReason34 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.cd.validate()?;
		if let Some(ref val) = self.addtl_rsn_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_rsn_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 210 {
				return Err(ValidationError::new(1002, "addtl_rsn_inf exceeds the maximum length of 210".to_string()));
			}
		}
		Ok(())
	}
}


// RejectionOrRepairStatus38Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RejectionOrRepairStatus38Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NoSpcfdRsn", skip_serializing_if = "Option::is_none") )]
	pub no_spcfd_rsn: Option<NoReasonCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<Vec<RejectionOrRepairReason32>>,
}

impl RejectionOrRepairStatus38Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.no_spcfd_rsn { val.validate()? }
		if let Some(ref vec) = self.rsn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// RejectionOrRepairStatus39Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RejectionOrRepairStatus39Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NoSpcfdRsn", skip_serializing_if = "Option::is_none") )]
	pub no_spcfd_rsn: Option<NoReasonCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<Vec<RejectionOrRepairReason33>>,
}

impl RejectionOrRepairStatus39Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.no_spcfd_rsn { val.validate()? }
		if let Some(ref vec) = self.rsn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// RejectionOrRepairStatus40Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RejectionOrRepairStatus40Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NoSpcfdRsn", skip_serializing_if = "Option::is_none") )]
	pub no_spcfd_rsn: Option<NoReasonCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<Vec<RejectionOrRepairReason34>>,
}

impl RejectionOrRepairStatus40Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.no_spcfd_rsn { val.validate()? }
		if let Some(ref vec) = self.rsn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// RejectionReason2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RejectionReason2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RjctgPtyRsn") )]
	pub rjctg_pty_rsn: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RjctnDtTm", skip_serializing_if = "Option::is_none") )]
	pub rjctn_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ErrLctn", skip_serializing_if = "Option::is_none") )]
	pub err_lctn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RsnDesc", skip_serializing_if = "Option::is_none") )]
	pub rsn_desc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlData", skip_serializing_if = "Option::is_none") )]
	pub addtl_data: Option<String>,
}

impl RejectionReason2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.rjctg_pty_rsn.chars().count() < 1 {
			return Err(ValidationError::new(1001, "rjctg_pty_rsn is shorter than the minimum length of 1".to_string()));
		}
		if self.rjctg_pty_rsn.chars().count() > 35 {
			return Err(ValidationError::new(1002, "rjctg_pty_rsn exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.err_lctn {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "err_lctn is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "err_lctn exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.rsn_desc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rsn_desc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "rsn_desc exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.addtl_data {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_data is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 20000 {
				return Err(ValidationError::new(1002, "addtl_data exceeds the maximum length of 20000".to_string()));
			}
		}
		Ok(())
	}
}


// RejectionReason31 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RejectionReason31 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn") )]
	pub rsn: RejectedReason16Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlRsnInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_rsn_inf: Option<String>,
}

impl RejectionReason31 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.rsn.validate()?;
		if let Some(ref val) = self.addtl_rsn_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_rsn_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "addtl_rsn_inf exceeds the maximum length of 350".to_string()));
			}
		}
		Ok(())
	}
}


// RejectionReason33Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum RejectionReason33Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CASH") )]
	CodeCASH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ADEA") )]
	CodeADEA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DMON") )]
	CodeDMON,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NCRR") )]
	CodeNCRR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LATE") )]
	CodeLATE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INVL") )]
	CodeINVL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INVB") )]
	CodeINVB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INVN") )]
	CodeINVN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VALR") )]
	CodeVALR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MONY") )]
	CodeMONY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CAEV") )]
	CodeCAEV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DDAT") )]
	CodeDDAT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REFE") )]
	CodeREFE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DQUA") )]
	CodeDQUA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DSEC") )]
	CodeDSEC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MINO") )]
	CodeMINO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MUNO") )]
	CodeMUNO,
}

impl RejectionReason33Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// RejectionReason34Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum RejectionReason34Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ADEA") )]
	CodeADEA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LATE") )]
	CodeLATE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CASH") )]
	CodeCASH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NRGM") )]
	CodeNRGM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NRGN") )]
	CodeNRGN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REFE") )]
	CodeREFE,
}

impl RejectionReason34Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// RejectionReason35Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum RejectionReason35Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CASH") )]
	CodeCASH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ADEA") )]
	CodeADEA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REFE") )]
	CodeREFE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LATE") )]
	CodeLATE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DDAT") )]
	CodeDDAT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NRGN") )]
	CodeNRGN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INVM") )]
	CodeINVM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INVL") )]
	CodeINVL,
}

impl RejectionReason35Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// RejectionReason45 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RejectionReason45 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgRptId") )]
	pub msg_rpt_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts") )]
	pub sts: ReportingMessageStatus1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtldVldtnRule", skip_serializing_if = "Option::is_none") )]
	pub dtld_vldtn_rule: Option<GenericValidationRuleIdentification1>,
}

impl RejectionReason45 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_rpt_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_rpt_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_rpt_id.chars().count() > 140 {
			return Err(ValidationError::new(1002, "msg_rpt_id exceeds the maximum length of 140".to_string()));
		}
		self.sts.validate()?;
		if let Some(ref val) = self.dtld_vldtn_rule { val.validate()? }
		Ok(())
	}
}


// RejectionReason53 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RejectionReason53 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxId") )]
	pub tx_id: TransactionIdentification3Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts") )]
	pub sts: ReportingMessageStatus1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtldVldtnRule", skip_serializing_if = "Option::is_none") )]
	pub dtld_vldtn_rule: Option<Vec<GenericValidationRuleIdentification1>>,
}

impl RejectionReason53 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tx_id.validate()?;
		self.sts.validate()?;
		if let Some(ref vec) = self.dtld_vldtn_rule { for item in vec { item.validate()? } }
		Ok(())
	}
}


// RejectionReason70 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RejectionReason70 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgRptId") )]
	pub msg_rpt_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts") )]
	pub sts: ReportingMessageStatus2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtldVldtnRule", skip_serializing_if = "Option::is_none") )]
	pub dtld_vldtn_rule: Option<GenericValidationRuleIdentification1>,
}

impl RejectionReason70 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_rpt_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_rpt_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_rpt_id.chars().count() > 140 {
			return Err(ValidationError::new(1002, "msg_rpt_id exceeds the maximum length of 140".to_string()));
		}
		self.sts.validate()?;
		if let Some(ref val) = self.dtld_vldtn_rule { val.validate()? }
		Ok(())
	}
}


// RejectionReason71 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RejectionReason71 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxId") )]
	pub tx_id: TradeTransactionIdentification24,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts") )]
	pub sts: ReportingMessageStatus2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtldVldtnRule", skip_serializing_if = "Option::is_none") )]
	pub dtld_vldtn_rule: Option<Vec<GenericValidationRuleIdentification1>>,
}

impl RejectionReason71 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tx_id.validate()?;
		self.sts.validate()?;
		if let Some(ref vec) = self.dtld_vldtn_rule { for item in vec { item.validate()? } }
		Ok(())
	}
}


// RejectionStatistics9 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RejectionStatistics9 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtyId") )]
	pub ctr_pty_id: CounterpartyData92,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptSttstcs") )]
	pub rpt_sttstcs: DetailedReportStatistics7,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DerivSttstcs") )]
	pub deriv_sttstcs: DetailedTransactionStatistics7Choice,
}

impl RejectionStatistics9 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.ctr_pty_id.validate()?;
		self.rpt_sttstcs.validate()?;
		self.deriv_sttstcs.validate()?;
		Ok(())
	}
}


// RelatedInvestigationData1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RelatedInvestigationData1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstgtnId", skip_serializing_if = "Option::is_none") )]
	pub invstgtn_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Lctn", skip_serializing_if = "Option::is_none") )]
	pub lctn: Option<Vec<InvestigationLocationData1>>,
}

impl RelatedInvestigationData1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.invstgtn_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "invstgtn_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "invstgtn_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref vec) = self.lctn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// RelatedNotificationData1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RelatedNotificationData1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtfctnId", skip_serializing_if = "Option::is_none") )]
	pub ntfctn_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Lctn", skip_serializing_if = "Option::is_none") )]
	pub lctn: Option<Vec<NotificationLocationData1>>,
}

impl RelatedNotificationData1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ntfctn_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ntfctn_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "ntfctn_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref vec) = self.lctn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// Remittance1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Remittance1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ustrd", skip_serializing_if = "Option::is_none") )]
	pub ustrd: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Strd", skip_serializing_if = "Option::is_none") )]
	pub strd: Option<Vec<StructuredRemittanceInformation16>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rltd", skip_serializing_if = "Option::is_none") )]
	pub rltd: Option<Vec<RemittanceLocation7>>,
}

impl Remittance1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.ustrd {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "ustrd is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 140 {
					return Err(ValidationError::new(1002, "ustrd exceeds the maximum length of 140".to_string()));
				}
			}
		}
		if let Some(ref vec) = self.strd { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.rltd { for item in vec { item.validate()? } }
		Ok(())
	}
}


// RemittanceAmount2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RemittanceAmount2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DuePyblAmt", skip_serializing_if = "Option::is_none") )]
	pub due_pybl_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DscntApldAmt", skip_serializing_if = "Option::is_none") )]
	pub dscnt_apld_amt: Option<Vec<DiscountAmountAndType1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtNoteAmt", skip_serializing_if = "Option::is_none") )]
	pub cdt_note_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxAmt", skip_serializing_if = "Option::is_none") )]
	pub tax_amt: Option<Vec<TaxAmountAndType1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AdjstmntAmtAndRsn", skip_serializing_if = "Option::is_none") )]
	pub adjstmnt_amt_and_rsn: Option<Vec<DocumentAdjustment1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RmtdAmt", skip_serializing_if = "Option::is_none") )]
	pub rmtd_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
}

impl RemittanceAmount2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.due_pybl_amt { val.validate()? }
		if let Some(ref vec) = self.dscnt_apld_amt { for item in vec { item.validate()? } }
		if let Some(ref val) = self.cdt_note_amt { val.validate()? }
		if let Some(ref vec) = self.tax_amt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.adjstmnt_amt_and_rsn { for item in vec { item.validate()? } }
		if let Some(ref val) = self.rmtd_amt { val.validate()? }
		Ok(())
	}
}


// RemittanceAmount3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RemittanceAmount3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DuePyblAmt", skip_serializing_if = "Option::is_none") )]
	pub due_pybl_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DscntApldAmt", skip_serializing_if = "Option::is_none") )]
	pub dscnt_apld_amt: Option<Vec<DiscountAmountAndType1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtNoteAmt", skip_serializing_if = "Option::is_none") )]
	pub cdt_note_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxAmt", skip_serializing_if = "Option::is_none") )]
	pub tax_amt: Option<Vec<TaxAmountAndType1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AdjstmntAmtAndRsn", skip_serializing_if = "Option::is_none") )]
	pub adjstmnt_amt_and_rsn: Option<Vec<DocumentAdjustment1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RmtdAmt", skip_serializing_if = "Option::is_none") )]
	pub rmtd_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
}

impl RemittanceAmount3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.due_pybl_amt { val.validate()? }
		if let Some(ref vec) = self.dscnt_apld_amt { for item in vec { item.validate()? } }
		if let Some(ref val) = self.cdt_note_amt { val.validate()? }
		if let Some(ref vec) = self.tax_amt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.adjstmnt_amt_and_rsn { for item in vec { item.validate()? } }
		if let Some(ref val) = self.rmtd_amt { val.validate()? }
		Ok(())
	}
}


// RemittanceAmount4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RemittanceAmount4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RmtAmtAndTp", skip_serializing_if = "Option::is_none") )]
	pub rmt_amt_and_tp: Option<Vec<DocumentAmount1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AdjstmntAmtAndRsn", skip_serializing_if = "Option::is_none") )]
	pub adjstmnt_amt_and_rsn: Option<Vec<DocumentAdjustment1>>,
}

impl RemittanceAmount4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.rmt_amt_and_tp { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.adjstmnt_amt_and_rsn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// RemittanceInformation2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RemittanceInformation2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ustrd", skip_serializing_if = "Option::is_none") )]
	pub ustrd: Option<Vec<String>>,
}

impl RemittanceInformation2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.ustrd {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "ustrd is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 140 {
					return Err(ValidationError::new(1002, "ustrd exceeds the maximum length of 140".to_string()));
				}
			}
		}
		Ok(())
	}
}


// RemittanceInformation21 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RemittanceInformation21 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ustrd", skip_serializing_if = "Option::is_none") )]
	pub ustrd: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Strd", skip_serializing_if = "Option::is_none") )]
	pub strd: Option<Vec<StructuredRemittanceInformation17>>,
}

impl RemittanceInformation21 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.ustrd {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "ustrd is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 140 {
					return Err(ValidationError::new(1002, "ustrd exceeds the maximum length of 140".to_string()));
				}
			}
		}
		if let Some(ref vec) = self.strd { for item in vec { item.validate()? } }
		Ok(())
	}
}


// RemittanceInformation22 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RemittanceInformation22 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ustrd", skip_serializing_if = "Option::is_none") )]
	pub ustrd: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Strd", skip_serializing_if = "Option::is_none") )]
	pub strd: Option<Vec<StructuredRemittanceInformation18>>,
}

impl RemittanceInformation22 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.ustrd {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "ustrd is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 140 {
					return Err(ValidationError::new(1002, "ustrd exceeds the maximum length of 140".to_string()));
				}
			}
		}
		if let Some(ref vec) = self.strd { for item in vec { item.validate()? } }
		Ok(())
	}
}


// RemittanceInformation23 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RemittanceInformation23 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RmtId", skip_serializing_if = "Option::is_none") )]
	pub rmt_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ustrd", skip_serializing_if = "Option::is_none") )]
	pub ustrd: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Strd", skip_serializing_if = "Option::is_none") )]
	pub strd: Option<Vec<StructuredRemittanceInformation18>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlPmtInf") )]
	pub orgnl_pmt_inf: OriginalPaymentInformation10,
}

impl RemittanceInformation23 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rmt_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rmt_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "rmt_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref vec) = self.ustrd {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "ustrd is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 140 {
					return Err(ValidationError::new(1002, "ustrd exceeds the maximum length of 140".to_string()));
				}
			}
		}
		if let Some(ref vec) = self.strd { for item in vec { item.validate()? } }
		self.orgnl_pmt_inf.validate()?;
		Ok(())
	}
}


// RemittanceLocation10 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RemittanceLocation10 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RmtId", skip_serializing_if = "Option::is_none") )]
	pub rmt_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RmtLctnDtls") )]
	pub rmt_lctn_dtls: Vec<RemittanceLocationData2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Refs") )]
	pub refs: TransactionReferences8,
}

impl RemittanceLocation10 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rmt_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rmt_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "rmt_id exceeds the maximum length of 35".to_string()));
			}
		}
		for item in &self.rmt_lctn_dtls { item.validate()? }
		self.refs.validate()?;
		Ok(())
	}
}


// RemittanceLocation7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RemittanceLocation7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RmtId", skip_serializing_if = "Option::is_none") )]
	pub rmt_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RmtLctnDtls", skip_serializing_if = "Option::is_none") )]
	pub rmt_lctn_dtls: Option<Vec<RemittanceLocationData1>>,
}

impl RemittanceLocation7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rmt_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rmt_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "rmt_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref vec) = self.rmt_lctn_dtls { for item in vec { item.validate()? } }
		Ok(())
	}
}


// RemittanceLocation8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RemittanceLocation8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RmtId", skip_serializing_if = "Option::is_none") )]
	pub rmt_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RmtLctnDtls", skip_serializing_if = "Option::is_none") )]
	pub rmt_lctn_dtls: Option<Vec<RemittanceLocationData2>>,
}

impl RemittanceLocation8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rmt_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rmt_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "rmt_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref vec) = self.rmt_lctn_dtls { for item in vec { item.validate()? } }
		Ok(())
	}
}


// RemittanceLocation9 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RemittanceLocation9 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RmtId", skip_serializing_if = "Option::is_none") )]
	pub rmt_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RmtLctnMtd", skip_serializing_if = "Option::is_none") )]
	pub rmt_lctn_mtd: Option<RemittanceLocationMethod2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RmtLctnElctrncAdr", skip_serializing_if = "Option::is_none") )]
	pub rmt_lctn_elctrnc_adr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RmtLctnPstlAdr", skip_serializing_if = "Option::is_none") )]
	pub rmt_lctn_pstl_adr: Option<NameAndAddress18>,
}

impl RemittanceLocation9 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rmt_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rmt_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "rmt_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.rmt_lctn_mtd { val.validate()? }
		if let Some(ref val) = self.rmt_lctn_elctrnc_adr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rmt_lctn_elctrnc_adr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 2048 {
				return Err(ValidationError::new(1002, "rmt_lctn_elctrnc_adr exceeds the maximum length of 2048".to_string()));
			}
		}
		if let Some(ref val) = self.rmt_lctn_pstl_adr { val.validate()? }
		Ok(())
	}
}


// RemittanceLocationData1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RemittanceLocationData1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mtd") )]
	pub mtd: RemittanceLocationMethod2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ElctrncAdr", skip_serializing_if = "Option::is_none") )]
	pub elctrnc_adr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstlAdr", skip_serializing_if = "Option::is_none") )]
	pub pstl_adr: Option<NameAndAddress16>,
}

impl RemittanceLocationData1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.mtd.validate()?;
		if let Some(ref val) = self.elctrnc_adr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "elctrnc_adr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 2048 {
				return Err(ValidationError::new(1002, "elctrnc_adr exceeds the maximum length of 2048".to_string()));
			}
		}
		if let Some(ref val) = self.pstl_adr { val.validate()? }
		Ok(())
	}
}


// RemittanceLocationData2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RemittanceLocationData2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mtd") )]
	pub mtd: RemittanceLocationMethod2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ElctrncAdr", skip_serializing_if = "Option::is_none") )]
	pub elctrnc_adr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstlAdr", skip_serializing_if = "Option::is_none") )]
	pub pstl_adr: Option<NameAndAddress18>,
}

impl RemittanceLocationData2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.mtd.validate()?;
		if let Some(ref val) = self.elctrnc_adr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "elctrnc_adr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 2048 {
				return Err(ValidationError::new(1002, "elctrnc_adr exceeds the maximum length of 2048".to_string()));
			}
		}
		if let Some(ref val) = self.pstl_adr { val.validate()? }
		Ok(())
	}
}


// RemittanceLocationMethod2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum RemittanceLocationMethod2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "FAXI") )]
	CodeFAXI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EDIC") )]
	CodeEDIC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "URID") )]
	CodeURID,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EMAL") )]
	CodeEMAL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "POST") )]
	CodePOST,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SMSM") )]
	CodeSMSM,
}

impl RemittanceLocationMethod2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Repartition6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Repartition6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Qty") )]
	pub qty: UnitsOrAmountOrPercentage1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrm") )]
	pub fin_instrm: FinancialInstrument87,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CcyOfPlan", skip_serializing_if = "Option::is_none") )]
	pub ccy_of_plan: Option<String>,
}

impl Repartition6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.qty.validate()?;
		self.fin_instrm.validate()?;
		if let Some(ref val) = self.ccy_of_plan {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ccy_of_plan does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// RepoTerminationOption2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum RepoTerminationOption2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "EGRN") )]
	CodeEGRN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EGAE") )]
	CodeEGAE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ETSB") )]
	CodeETSB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NOAP") )]
	CodeNOAP,
}

impl RepoTerminationOption2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ReportData4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReportData4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValDt") )]
	pub val_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtAndTmStmp") )]
	pub dt_and_tm_stmp: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: Entry2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SchdlTp") )]
	pub schdl_tp: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmSsnIdr", skip_serializing_if = "Option::is_none") )]
	pub sttlm_ssn_idr: Option<String>,
}

impl ReportData4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		self.tp.validate()?;
		let pattern = Regex::new("[a-zA-Z0-9]{4}").unwrap();
		if !pattern.is_match(&self.schdl_tp) {
			return Err(ValidationError::new(1005, "schdl_tp does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.sttlm_ssn_idr {
			let pattern = Regex::new("[a-zA-Z0-9]{4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "sttlm_ssn_idr does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// ReportData5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReportData5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValDt") )]
	pub val_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtAndTmStmp") )]
	pub dt_and_tm_stmp: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: CallIn1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PayInCallAmt", skip_serializing_if = "Option::is_none") )]
	pub pay_in_call_amt: Option<Vec<PayInCallItem>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmSsnIdr", skip_serializing_if = "Option::is_none") )]
	pub sttlm_ssn_idr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctVal", skip_serializing_if = "Option::is_none") )]
	pub acct_val: Option<Value>,
}

impl ReportData5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		self.tp.validate()?;
		if let Some(ref vec) = self.pay_in_call_amt { for item in vec { item.validate()? } }
		if let Some(ref val) = self.sttlm_ssn_idr {
			let pattern = Regex::new("[a-zA-Z0-9]{4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "sttlm_ssn_idr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.acct_val { val.validate()? }
		Ok(())
	}
}


// ReportEntry14 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReportEntry14 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtryRef", skip_serializing_if = "Option::is_none") )]
	pub ntry_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveOrHistoricCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbtInd") )]
	pub cdt_dbt_ind: CreditDebitCode,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RvslInd", skip_serializing_if = "Option::is_none") )]
	pub rvsl_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts") )]
	pub sts: EntryStatus1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BookgDt", skip_serializing_if = "Option::is_none") )]
	pub bookg_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValDt", skip_serializing_if = "Option::is_none") )]
	pub val_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcrRef", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Avlbty", skip_serializing_if = "Option::is_none") )]
	pub avlbty: Option<Vec<CashAvailability1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BkTxCd") )]
	pub bk_tx_cd: BankTransactionCodeStructure4,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ComssnWvrInd", skip_serializing_if = "Option::is_none") )]
	pub comssn_wvr_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInfInd", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf_ind: Option<MessageIdentification2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AmtDtls", skip_serializing_if = "Option::is_none") )]
	pub amt_dtls: Option<AmountAndCurrencyExchange4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Chrgs", skip_serializing_if = "Option::is_none") )]
	pub chrgs: Option<Charges15>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechInptChanl", skip_serializing_if = "Option::is_none") )]
	pub tech_inpt_chanl: Option<TechnicalInputChannel1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Intrst", skip_serializing_if = "Option::is_none") )]
	pub intrst: Option<TransactionInterest4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CardTx", skip_serializing_if = "Option::is_none") )]
	pub card_tx: Option<CardEntry5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtryDtls", skip_serializing_if = "Option::is_none") )]
	pub ntry_dtls: Option<Vec<EntryDetails13>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlNtryInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_ntry_inf: Option<String>,
}

impl ReportEntry14 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ntry_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ntry_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "ntry_ref exceeds the maximum length of 35".to_string()));
			}
		}
		self.amt.validate()?;
		self.cdt_dbt_ind.validate()?;
		self.sts.validate()?;
		if let Some(ref val) = self.bookg_dt { val.validate()? }
		if let Some(ref val) = self.val_dt { val.validate()? }
		if let Some(ref val) = self.acct_svcr_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_svcr_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acct_svcr_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref vec) = self.avlbty { for item in vec { item.validate()? } }
		self.bk_tx_cd.validate()?;
		if let Some(ref val) = self.addtl_inf_ind { val.validate()? }
		if let Some(ref val) = self.amt_dtls { val.validate()? }
		if let Some(ref val) = self.chrgs { val.validate()? }
		if let Some(ref val) = self.tech_inpt_chanl { val.validate()? }
		if let Some(ref val) = self.intrst { val.validate()? }
		if let Some(ref val) = self.card_tx { val.validate()? }
		if let Some(ref vec) = self.ntry_dtls { for item in vec { item.validate()? } }
		if let Some(ref val) = self.addtl_ntry_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_ntry_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 500 {
				return Err(ValidationError::new(1002, "addtl_ntry_inf exceeds the maximum length of 500".to_string()));
			}
		}
		Ok(())
	}
}


// ReportHeader6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReportHeader6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptId") )]
	pub rpt_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgPgntn", skip_serializing_if = "Option::is_none") )]
	pub msg_pgntn: Option<Pagination1>,
}

impl ReportHeader6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.rpt_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "rpt_id is shorter than the minimum length of 1".to_string()));
		}
		if self.rpt_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "rpt_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.msg_pgntn { val.validate()? }
		Ok(())
	}
}


// ReportHeader7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReportHeader7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Fr") )]
	pub fr: Party50Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "To") )]
	pub to: Party50Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm") )]
	pub cre_dt_tm: String,
}

impl ReportHeader7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		self.fr.validate()?;
		self.to.validate()?;
		Ok(())
	}
}


// ReportIndicator1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ReportIndicator1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "STND") )]
	CodeSTND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRPR") )]
	CodePRPR,
}

impl ReportIndicator1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ReportParameter1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReportParameter1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm") )]
	pub nm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val") )]
	pub val: String,
}

impl ReportParameter1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
		}
		if self.nm.chars().count() > 70 {
			return Err(ValidationError::new(1002, "nm exceeds the maximum length of 70".to_string()));
		}
		if self.val.chars().count() < 1 {
			return Err(ValidationError::new(1001, "val is shorter than the minimum length of 1".to_string()));
		}
		if self.val.chars().count() > 350 {
			return Err(ValidationError::new(1002, "val exceeds the maximum length of 350".to_string()));
		}
		Ok(())
	}
}


// ReportPeriodActivity1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ReportPeriodActivity1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "NOTX") )]
	CodeNOTX,
}

impl ReportPeriodActivity1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ReportPeriodActivity3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ReportPeriodActivity3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "NOTX") )]
	CodeNOTX,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NORA") )]
	CodeNORA,
}

impl ReportPeriodActivity3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ReportQueryCriteria3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReportQueryCriteria3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NewQryNm", skip_serializing_if = "Option::is_none") )]
	pub new_qry_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SchCrit") )]
	pub sch_crit: ReportQuerySearchCriteria3,
}

impl ReportQueryCriteria3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.new_qry_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "new_qry_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "new_qry_nm exceeds the maximum length of 35".to_string()));
			}
		}
		self.sch_crit.validate()?;
		Ok(())
	}
}


// ReportQuerySearchCriteria3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReportQuerySearchCriteria3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctId", skip_serializing_if = "Option::is_none") )]
	pub acct_id: Option<Vec<AccountIdentificationSearchCriteria2Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Bal", skip_serializing_if = "Option::is_none") )]
	pub bal: Option<Vec<CashBalance14>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptNm", skip_serializing_if = "Option::is_none") )]
	pub rpt_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgNmId", skip_serializing_if = "Option::is_none") )]
	pub msg_nm_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtyId") )]
	pub pty_id: PartyIdentification136,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RspnsblPtyId", skip_serializing_if = "Option::is_none") )]
	pub rspnsbl_pty_id: Option<PartyIdentification136>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtSch", skip_serializing_if = "Option::is_none") )]
	pub dt_sch: Option<DatePeriodSearch1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SchdldTm", skip_serializing_if = "Option::is_none") )]
	pub schdld_tm: Option<DateTimePeriod1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Evt", skip_serializing_if = "Option::is_none") )]
	pub evt: Option<EventType1Choice>,
}

impl ReportQuerySearchCriteria3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.acct_id { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.bal { for item in vec { item.validate()? } }
		if let Some(ref val) = self.rpt_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rpt_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "rpt_nm exceeds the maximum length of 4".to_string()));
			}
			let pattern = Regex::new("[a-zA-Z0-9]{1,4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "rpt_nm does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.msg_nm_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "msg_nm_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "msg_nm_id exceeds the maximum length of 35".to_string()));
			}
		}
		self.pty_id.validate()?;
		if let Some(ref val) = self.rspnsbl_pty_id { val.validate()? }
		if let Some(ref val) = self.dt_sch { val.validate()? }
		if let Some(ref val) = self.schdld_tm { val.validate()? }
		if let Some(ref val) = self.evt { val.validate()? }
		Ok(())
	}
}


// ReportingAssetBreakdown1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReportingAssetBreakdown1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgAsstTp") )]
	pub rptg_asst_tp: ProductType6Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveCurrencyAndAmount,
}

impl ReportingAssetBreakdown1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.rptg_asst_tp.validate()?;
		if let Some(ref val) = self.id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "id exceeds the maximum length of 350".to_string()));
			}
		}
		self.amt.validate()?;
		Ok(())
	}
}


// ReportingExemption1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReportingExemption1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn") )]
	pub rsn: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Desc", skip_serializing_if = "Option::is_none") )]
	pub desc: Option<String>,
}

impl ReportingExemption1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.rsn.chars().count() < 1 {
			return Err(ValidationError::new(1001, "rsn is shorter than the minimum length of 1".to_string()));
		}
		if self.rsn.chars().count() > 4 {
			return Err(ValidationError::new(1002, "rsn exceeds the maximum length of 4".to_string()));
		}
		if let Some(ref val) = self.desc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "desc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 1000 {
				return Err(ValidationError::new(1002, "desc exceeds the maximum length of 1000".to_string()));
			}
		}
		Ok(())
	}
}


// ReportingMessageStatus1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ReportingMessageStatus1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACPT") )]
	CodeACPT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACTC") )]
	CodeACTC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PART") )]
	CodePART,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RCVD") )]
	CodeRCVD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RJCT") )]
	CodeRJCT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RMDR") )]
	CodeRMDR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WARN") )]
	CodeWARN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INCF") )]
	CodeINCF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CRPT") )]
	CodeCRPT,
}

impl ReportingMessageStatus1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ReportingMessageStatus2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ReportingMessageStatus2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACPT") )]
	CodeACPT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RJCT") )]
	CodeRJCT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INCF") )]
	CodeINCF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CRPT") )]
	CodeCRPT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NAUT") )]
	CodeNAUT,
}

impl ReportingMessageStatus2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ReportingPeriod4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReportingPeriod4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrToDt") )]
	pub fr_to_dt: DatePeriod3,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrToTm") )]
	pub fr_to_tm: TimePeriod2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: QueryType3Code,
}

impl ReportingPeriod4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.fr_to_dt.validate()?;
		self.fr_to_tm.validate()?;
		self.tp.validate()?;
		Ok(())
	}
}


// ReportingPeriod5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReportingPeriod5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrToDt") )]
	pub fr_to_dt: DatePeriod3,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrToTm", skip_serializing_if = "Option::is_none") )]
	pub fr_to_tm: Option<TimePeriodDetails1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: QueryType3Code,
}

impl ReportingPeriod5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.fr_to_dt.validate()?;
		if let Some(ref val) = self.fr_to_tm { val.validate()? }
		self.tp.validate()?;
		Ok(())
	}
}


// ReportingRecordStatus1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ReportingRecordStatus1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACPT") )]
	CodeACPT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACPD") )]
	CodeACPD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PDNG") )]
	CodePDNG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RCVD") )]
	CodeRCVD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RJCT") )]
	CodeRJCT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RJPD") )]
	CodeRJPD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WARN") )]
	CodeWARN,
}

impl ReportingRecordStatus1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ReportingRequest7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReportingRequest7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdMsgNmId") )]
	pub reqd_msg_nm_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Acct", skip_serializing_if = "Option::is_none") )]
	pub acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctOwnr") )]
	pub acct_ownr: Party50Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcr", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgPrd", skip_serializing_if = "Option::is_none") )]
	pub rptg_prd: Option<ReportingPeriod5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgSeq", skip_serializing_if = "Option::is_none") )]
	pub rptg_seq: Option<SequenceRange1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdTxTp", skip_serializing_if = "Option::is_none") )]
	pub reqd_tx_tp: Option<TransactionType2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdBalTp", skip_serializing_if = "Option::is_none") )]
	pub reqd_bal_tp: Option<Vec<BalanceType13>>,
}

impl ReportingRequest7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
			}
		}
		if self.reqd_msg_nm_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "reqd_msg_nm_id is shorter than the minimum length of 1".to_string()));
		}
		if self.reqd_msg_nm_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "reqd_msg_nm_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.acct { val.validate()? }
		self.acct_ownr.validate()?;
		if let Some(ref val) = self.acct_svcr { val.validate()? }
		if let Some(ref val) = self.rptg_prd { val.validate()? }
		if let Some(ref val) = self.rptg_seq { val.validate()? }
		if let Some(ref val) = self.reqd_tx_tp { val.validate()? }
		if let Some(ref vec) = self.reqd_bal_tp { for item in vec { item.validate()? } }
		Ok(())
	}
}


// ReportingRequirement3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReportingRequirement3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgRqrmnt", skip_serializing_if = "Option::is_none") )]
	pub rptg_rqrmnt: Option<ReconciliationCategory5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NoRptgRqrmnt", skip_serializing_if = "Option::is_none") )]
	pub no_rptg_rqrmnt: Option<ReconciliationCategory4>,
}

impl ReportingRequirement3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rptg_rqrmnt { val.validate()? }
		if let Some(ref val) = self.no_rptg_rqrmnt { val.validate()? }
		Ok(())
	}
}


// ReportingSource1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReportingSource1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl ReportingSource1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// ReportingTransactionType3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReportingTransactionType3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "New", skip_serializing_if = "Option::is_none") )]
	pub new: Option<SecuritiesTransactionReport7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cxl", skip_serializing_if = "Option::is_none") )]
	pub cxl: Option<SecuritiesTransactionReport2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl ReportingTransactionType3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.new { val.validate()? }
		if let Some(ref val) = self.cxl { val.validate()? }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// ReportingWaiverType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ReportingWaiverType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "OILQ") )]
	CodeOILQ,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NLIQ") )]
	CodeNLIQ,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRIC") )]
	CodePRIC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ILQD") )]
	CodeILQD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RFPT") )]
	CodeRFPT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SIZE") )]
	CodeSIZE,
}

impl ReportingWaiverType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ReportingWaiverType3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ReportingWaiverType3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "BENC") )]
	CodeBENC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACTX") )]
	CodeACTX,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ILQD") )]
	CodeILQD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SIZE") )]
	CodeSIZE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CANC") )]
	CodeCANC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AMND") )]
	CodeAMND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SDIV") )]
	CodeSDIV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RPRI") )]
	CodeRPRI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DUPL") )]
	CodeDUPL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LRGS") )]
	CodeLRGS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TNCP") )]
	CodeTNCP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TPAC") )]
	CodeTPAC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XFPH") )]
	CodeXFPH,
}

impl ReportingWaiverType3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// RepurchaseAgreement2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RepurchaseAgreement2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MtrtyDt") )]
	pub mtrty_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ScndLegPric") )]
	pub scnd_leg_pric: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollMktVal") )]
	pub coll_mkt_val: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPty") )]
	pub ctr_pty: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RpAgrmtTp") )]
	pub rp_agrmt_tp: RepurchaseAgreementType3Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrptyAgtId", skip_serializing_if = "Option::is_none") )]
	pub trpty_agt_id: Option<String>,
}

impl RepurchaseAgreement2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.scnd_leg_pric.validate()?;
		self.coll_mkt_val.validate()?;
		let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
		if !pattern.is_match(&self.ctr_pty) {
			return Err(ValidationError::new(1005, "ctr_pty does not match the required pattern".to_string()));
		}
		self.rp_agrmt_tp.validate()?;
		if let Some(ref val) = self.trpty_agt_id {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "trpty_agt_id does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// RepurchaseAgreement3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RepurchaseAgreement3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PdctClssfctn") )]
	pub pdct_clssfctn: ProductClassification1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RpAgrmtTp") )]
	pub rp_agrmt_tp: RepurchaseAgreementType1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrptyAgt", skip_serializing_if = "Option::is_none") )]
	pub trpty_agt: Option<String>,
}

impl RepurchaseAgreement3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pdct_clssfctn.validate()?;
		self.rp_agrmt_tp.validate()?;
		if let Some(ref val) = self.trpty_agt {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "trpty_agt does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// RepurchaseAgreementType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RepurchaseAgreementType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SpcfcColl", skip_serializing_if = "Option::is_none") )]
	pub spcfc_coll: Option<SpecificCollateral2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GnlColl", skip_serializing_if = "Option::is_none") )]
	pub gnl_coll: Option<GeneralCollateral2>,
}

impl RepurchaseAgreementType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.spcfc_coll { val.validate()? }
		if let Some(ref val) = self.gnl_coll { val.validate()? }
		Ok(())
	}
}


// RepurchaseAgreementType3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RepurchaseAgreementType3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SpcfcColl", skip_serializing_if = "Option::is_none") )]
	pub spcfc_coll: Option<SpecificCollateral2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GnlColl", skip_serializing_if = "Option::is_none") )]
	pub gnl_coll: Option<GeneralCollateral3>,
}

impl RepurchaseAgreementType3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.spcfc_coll { val.validate()? }
		if let Some(ref val) = self.gnl_coll { val.validate()? }
		Ok(())
	}
}


// RequestData2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RequestData2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqTp") )]
	pub req_tp: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdActvtnDt") )]
	pub reqd_actvtn_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqSvcr", skip_serializing_if = "Option::is_none") )]
	pub req_svcr: Option<PartyIdentification242Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NetSvcPtcptId") )]
	pub net_svc_ptcpt_id: PartyIdentification242Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NetSvcTp", skip_serializing_if = "Option::is_none") )]
	pub net_svc_tp: Option<String>,
}

impl RequestData2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
		}
		if self.req_tp.chars().count() < 1 {
			return Err(ValidationError::new(1001, "req_tp is shorter than the minimum length of 1".to_string()));
		}
		if self.req_tp.chars().count() > 4 {
			return Err(ValidationError::new(1002, "req_tp exceeds the maximum length of 4".to_string()));
		}
		if let Some(ref val) = self.req_svcr { val.validate()? }
		self.net_svc_ptcpt_id.validate()?;
		if let Some(ref val) = self.net_svc_tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "net_svc_tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "net_svc_tp exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// RequestDetails22 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RequestDetails22 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ref") )]
	pub ref_attr: References14,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Lkg", skip_serializing_if = "Option::is_none") )]
	pub lkg: Option<LinkageType3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prty", skip_serializing_if = "Option::is_none") )]
	pub prty: Option<PriorityNumeric4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrPrcg", skip_serializing_if = "Option::is_none") )]
	pub othr_prcg: Option<Vec<GenericIdentification30>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtlSttlmInd", skip_serializing_if = "Option::is_none") )]
	pub prtl_sttlm_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrChanl", skip_serializing_if = "Option::is_none") )]
	pub clr_chanl: Option<ClearingChannel2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Lnkgs", skip_serializing_if = "Option::is_none") )]
	pub lnkgs: Option<Vec<Linkages57>>,
}

impl RequestDetails22 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.ref_attr.validate()?;
		if let Some(ref val) = self.lkg { val.validate()? }
		if let Some(ref val) = self.prty { val.validate()? }
		if let Some(ref vec) = self.othr_prcg { for item in vec { item.validate()? } }
		if let Some(ref val) = self.clr_chanl { val.validate()? }
		if let Some(ref vec) = self.lnkgs { for item in vec { item.validate()? } }
		Ok(())
	}
}


// RequestDetails3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RequestDetails3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Key", skip_serializing_if = "Option::is_none") )]
	pub key: Option<String>,
}

impl RequestDetails3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.tp.chars().count() < 1 {
			return Err(ValidationError::new(1001, "tp is shorter than the minimum length of 1".to_string()));
		}
		if self.tp.chars().count() > 35 {
			return Err(ValidationError::new(1002, "tp exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.key {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "key is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "key exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// RequestDetails30 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RequestDetails30 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RqstrId", skip_serializing_if = "Option::is_none") )]
	pub rqstr_id: Option<PartyIdentification242Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlReqInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_req_inf: Option<Vec<String>>,
}

impl RequestDetails30 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.tp.chars().count() < 1 {
			return Err(ValidationError::new(1001, "tp is shorter than the minimum length of 1".to_string()));
		}
		if self.tp.chars().count() > 35 {
			return Err(ValidationError::new(1002, "tp exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.rqstr_id { val.validate()? }
		if let Some(ref vec) = self.addtl_req_inf {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "addtl_req_inf is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 35 {
					return Err(ValidationError::new(1002, "addtl_req_inf exceeds the maximum length of 35".to_string()));
				}
			}
		}
		Ok(())
	}
}


// RequestDetails4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RequestDetails4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Key") )]
	pub key: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptData", skip_serializing_if = "Option::is_none") )]
	pub rpt_data: Option<Vec<ReportParameter1>>,
}

impl RequestDetails4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.key.chars().count() < 1 {
			return Err(ValidationError::new(1001, "key is shorter than the minimum length of 1".to_string()));
		}
		if self.key.chars().count() > 35 {
			return Err(ValidationError::new(1002, "key exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref vec) = self.rpt_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// RequestDetails5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RequestDetails5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqRef") )]
	pub req_ref: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptKey") )]
	pub rpt_key: Vec<RequestDetails4>,
}

impl RequestDetails5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.tp.chars().count() < 1 {
			return Err(ValidationError::new(1001, "tp is shorter than the minimum length of 1".to_string()));
		}
		if self.tp.chars().count() > 35 {
			return Err(ValidationError::new(1002, "tp exceeds the maximum length of 35".to_string()));
		}
		if self.req_ref.chars().count() < 1 {
			return Err(ValidationError::new(1001, "req_ref is shorter than the minimum length of 1".to_string()));
		}
		if self.req_ref.chars().count() > 35 {
			return Err(ValidationError::new(1002, "req_ref exceeds the maximum length of 35".to_string()));
		}
		for item in &self.rpt_key { item.validate()? }
		Ok(())
	}
}


// RequestHandling2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RequestHandling2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsCd") )]
	pub sts_cd: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsDtTm", skip_serializing_if = "Option::is_none") )]
	pub sts_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Desc", skip_serializing_if = "Option::is_none") )]
	pub desc: Option<String>,
}

impl RequestHandling2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.sts_cd.chars().count() < 1 {
			return Err(ValidationError::new(1001, "sts_cd is shorter than the minimum length of 1".to_string()));
		}
		if self.sts_cd.chars().count() > 4 {
			return Err(ValidationError::new(1002, "sts_cd exceeds the maximum length of 4".to_string()));
		}
		let pattern = Regex::new("[a-zA-Z0-9]{1,4}").unwrap();
		if !pattern.is_match(&self.sts_cd) {
			return Err(ValidationError::new(1005, "sts_cd does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.desc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "desc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "desc exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// RequestHandling3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RequestHandling3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts") )]
	pub sts: RequestStatus1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsRsn", skip_serializing_if = "Option::is_none") )]
	pub sts_rsn: Option<StatusReasonInformation14>,
}

impl RequestHandling3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.sts.validate()?;
		if let Some(ref val) = self.sts_rsn { val.validate()? }
		Ok(())
	}
}


// RequestStatus1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RequestStatus1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl RequestStatus1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// RequestType1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RequestType1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nb") )]
	pub nb: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: Vec<TransactionRequestType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
}

impl RequestType1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.nb.chars().count() < 1 {
			return Err(ValidationError::new(1001, "nb is shorter than the minimum length of 1".to_string()));
		}
		if self.nb.chars().count() > 35 {
			return Err(ValidationError::new(1002, "nb exceeds the maximum length of 35".to_string()));
		}
		for item in &self.tp { item.validate()? }
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 500 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 500".to_string()));
			}
		}
		Ok(())
	}
}


// RequestType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum RequestType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "RT01") )]
	CodeRT01,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RT02") )]
	CodeRT02,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RT03") )]
	CodeRT03,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RT04") )]
	CodeRT04,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RT05") )]
	CodeRT05,
}

impl RequestType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// RequestType2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RequestType2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtCtrl", skip_serializing_if = "Option::is_none") )]
	pub pmt_ctrl: Option<RequestType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Enqry", skip_serializing_if = "Option::is_none") )]
	pub enqry: Option<RequestType2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification1>,
}

impl RequestType2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.pmt_ctrl { val.validate()? }
		if let Some(ref val) = self.enqry { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// RequestType2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum RequestType2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "RT11") )]
	CodeRT11,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RT12") )]
	CodeRT12,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RT13") )]
	CodeRT13,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RT14") )]
	CodeRT14,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RT15") )]
	CodeRT15,
}

impl RequestType2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// RequestType3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RequestType3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<StandingOrderQueryType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification1>,
}

impl RequestType3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// RequestType4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RequestType4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtCtrl", skip_serializing_if = "Option::is_none") )]
	pub pmt_ctrl: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Enqry", skip_serializing_if = "Option::is_none") )]
	pub enqry: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification1>,
}

impl RequestType4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.pmt_ctrl {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pmt_ctrl is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "pmt_ctrl exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.enqry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "enqry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "enqry exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// RequestedModification11 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RequestedModification11 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrId", skip_serializing_if = "Option::is_none") )]
	pub instr_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndToEndId", skip_serializing_if = "Option::is_none") )]
	pub end_to_end_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxId", skip_serializing_if = "Option::is_none") )]
	pub tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtTpInf", skip_serializing_if = "Option::is_none") )]
	pub pmt_tp_inf: Option<PaymentTypeInformation27>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdExctnDt", skip_serializing_if = "Option::is_none") )]
	pub reqd_exctn_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdColltnDt", skip_serializing_if = "Option::is_none") )]
	pub reqd_colltn_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBkSttlmDt", skip_serializing_if = "Option::is_none") )]
	pub intr_bk_sttlm_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmTmIndctn", skip_serializing_if = "Option::is_none") )]
	pub sttlm_tm_indctn: Option<SettlementDateTimeIndication1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<AmountType4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBkSttlmAmt", skip_serializing_if = "Option::is_none") )]
	pub intr_bk_sttlm_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgBr", skip_serializing_if = "Option::is_none") )]
	pub chrg_br: Option<ChargeBearerType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtDbtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_dbtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dbtr", skip_serializing_if = "Option::is_none") )]
	pub dbtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmInf", skip_serializing_if = "Option::is_none") )]
	pub sttlm_inf: Option<SettlementInstruction16>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub cdtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cdtr", skip_serializing_if = "Option::is_none") )]
	pub cdtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAcct", skip_serializing_if = "Option::is_none") )]
	pub cdtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtCdtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_cdtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Purp", skip_serializing_if = "Option::is_none") )]
	pub purp: Option<Purpose2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrForDbtrAgt", skip_serializing_if = "Option::is_none") )]
	pub instr_for_dbtr_agt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrForNxtAgt", skip_serializing_if = "Option::is_none") )]
	pub instr_for_nxt_agt: Option<Vec<InstructionForNextAgent1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrForCdtrAgt", skip_serializing_if = "Option::is_none") )]
	pub instr_for_cdtr_agt: Option<Vec<InstructionForCreditorAgent3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdRmtInf", skip_serializing_if = "Option::is_none") )]
	pub rltd_rmt_inf: Option<Vec<RemittanceLocation8>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RmtInf", skip_serializing_if = "Option::is_none") )]
	pub rmt_inf: Option<RemittanceInformation22>,
}

impl RequestedModification11 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.instr_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "instr_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "instr_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.end_to_end_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "end_to_end_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "end_to_end_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.pmt_tp_inf { val.validate()? }
		if let Some(ref val) = self.reqd_exctn_dt { val.validate()? }
		if let Some(ref val) = self.sttlm_tm_indctn { val.validate()? }
		if let Some(ref val) = self.amt { val.validate()? }
		if let Some(ref val) = self.intr_bk_sttlm_amt { val.validate()? }
		if let Some(ref val) = self.chrg_br { val.validate()? }
		if let Some(ref val) = self.ultmt_dbtr { val.validate()? }
		if let Some(ref val) = self.dbtr { val.validate()? }
		if let Some(ref val) = self.dbtr_acct { val.validate()? }
		if let Some(ref val) = self.dbtr_agt_acct { val.validate()? }
		if let Some(ref val) = self.sttlm_inf { val.validate()? }
		if let Some(ref val) = self.cdtr_agt_acct { val.validate()? }
		if let Some(ref val) = self.cdtr { val.validate()? }
		if let Some(ref val) = self.cdtr_acct { val.validate()? }
		if let Some(ref val) = self.ultmt_cdtr { val.validate()? }
		if let Some(ref val) = self.purp { val.validate()? }
		if let Some(ref val) = self.instr_for_dbtr_agt {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "instr_for_dbtr_agt is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "instr_for_dbtr_agt exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref vec) = self.instr_for_nxt_agt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.instr_for_cdtr_agt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.rltd_rmt_inf { for item in vec { item.validate()? } }
		if let Some(ref val) = self.rmt_inf { val.validate()? }
		Ok(())
	}
}


// ResendSearchCriteria2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ResendSearchCriteria2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizDt", skip_serializing_if = "Option::is_none") )]
	pub biz_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SeqNb", skip_serializing_if = "Option::is_none") )]
	pub seq_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SeqRg", skip_serializing_if = "Option::is_none") )]
	pub seq_rg: Option<SequenceRange1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMsgNmId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_msg_nm_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FileRef", skip_serializing_if = "Option::is_none") )]
	pub file_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rcpt") )]
	pub rcpt: PartyIdentification136,
}

impl ResendSearchCriteria2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.seq_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "seq_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "seq_nb exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.seq_rg { val.validate()? }
		if let Some(ref val) = self.orgnl_msg_nm_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_msg_nm_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_msg_nm_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.file_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "file_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "file_ref exceeds the maximum length of 35".to_string()));
			}
		}
		self.rcpt.validate()?;
		Ok(())
	}
}


// Reservation3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Reservation3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: Amount2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts", skip_serializing_if = "Option::is_none") )]
	pub sts: Option<ReservationStatus1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StartDtTm", skip_serializing_if = "Option::is_none") )]
	pub start_dt_tm: Option<DateAndDateTime2Choice>,
}

impl Reservation3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.amt.validate()?;
		if let Some(ref val) = self.sts { val.validate()? }
		if let Some(ref val) = self.start_dt_tm { val.validate()? }
		Ok(())
	}
}


// Reservation4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Reservation4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "StartDtTm", skip_serializing_if = "Option::is_none") )]
	pub start_dt_tm: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: Amount2Choice,
}

impl Reservation4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.start_dt_tm { val.validate()? }
		self.amt.validate()?;
		Ok(())
	}
}


// ReservationCriteria6Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReservationCriteria6Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "QryNm", skip_serializing_if = "Option::is_none") )]
	pub qry_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NewCrit", skip_serializing_if = "Option::is_none") )]
	pub new_crit: Option<ReservationCriteria7>,
}

impl ReservationCriteria6Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.qry_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "qry_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "qry_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.new_crit { val.validate()? }
		Ok(())
	}
}


// ReservationCriteria7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReservationCriteria7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NewQryNm", skip_serializing_if = "Option::is_none") )]
	pub new_qry_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SchCrit", skip_serializing_if = "Option::is_none") )]
	pub sch_crit: Option<Vec<ReservationSearchCriteria6>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RtrCrit", skip_serializing_if = "Option::is_none") )]
	pub rtr_crit: Option<ReservationReturnCriteria1>,
}

impl ReservationCriteria7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.new_qry_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "new_qry_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "new_qry_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref vec) = self.sch_crit { for item in vec { item.validate()? } }
		if let Some(ref val) = self.rtr_crit { val.validate()? }
		Ok(())
	}
}


// ReservationIdentification4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReservationIdentification4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RsvatnId", skip_serializing_if = "Option::is_none") )]
	pub rsvatn_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SysId", skip_serializing_if = "Option::is_none") )]
	pub sys_id: Option<SystemIdentification2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: ReservationType2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctOwnr", skip_serializing_if = "Option::is_none") )]
	pub acct_ownr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctId", skip_serializing_if = "Option::is_none") )]
	pub acct_id: Option<AccountIdentification4Choice>,
}

impl ReservationIdentification4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rsvatn_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rsvatn_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "rsvatn_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.sys_id { val.validate()? }
		self.tp.validate()?;
		if let Some(ref val) = self.acct_ownr { val.validate()? }
		if let Some(ref val) = self.acct_id { val.validate()? }
		Ok(())
	}
}


// ReservationOrError11Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReservationOrError11Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizRpt", skip_serializing_if = "Option::is_none") )]
	pub biz_rpt: Option<CurrentAndDefaultReservation6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OprlErr", skip_serializing_if = "Option::is_none") )]
	pub oprl_err: Option<Vec<ErrorHandling5>>,
}

impl ReservationOrError11Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.biz_rpt { val.validate()? }
		if let Some(ref vec) = self.oprl_err { for item in vec { item.validate()? } }
		Ok(())
	}
}


// ReservationOrError9Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReservationOrError9Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsvatn", skip_serializing_if = "Option::is_none") )]
	pub rsvatn: Option<Reservation3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizErr", skip_serializing_if = "Option::is_none") )]
	pub biz_err: Option<Vec<ErrorHandling5>>,
}

impl ReservationOrError9Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rsvatn { val.validate()? }
		if let Some(ref vec) = self.biz_err { for item in vec { item.validate()? } }
		Ok(())
	}
}


// ReservationQuery6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReservationQuery6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "QryTp", skip_serializing_if = "Option::is_none") )]
	pub qry_tp: Option<QueryType2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RsvatnCrit", skip_serializing_if = "Option::is_none") )]
	pub rsvatn_crit: Option<ReservationCriteria6Choice>,
}

impl ReservationQuery6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.qry_tp { val.validate()? }
		if let Some(ref val) = self.rsvatn_crit { val.validate()? }
		Ok(())
	}
}


// ReservationReport8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReservationReport8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RsvatnId") )]
	pub rsvatn_id: ReservationIdentification4,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RsvatnOrErr") )]
	pub rsvatn_or_err: ReservationOrError9Choice,
}

impl ReservationReport8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.rsvatn_id.validate()?;
		self.rsvatn_or_err.validate()?;
		Ok(())
	}
}


// ReservationReturnCriteria1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReservationReturnCriteria1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "StartDtTmInd", skip_serializing_if = "Option::is_none") )]
	pub start_dt_tm_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsInd", skip_serializing_if = "Option::is_none") )]
	pub sts_ind: Option<bool>,
}

impl ReservationReturnCriteria1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ReservationSearchCriteria6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReservationSearchCriteria6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtTm", skip_serializing_if = "Option::is_none") )]
	pub dt_tm: Option<DateTimeSearch2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SysId", skip_serializing_if = "Option::is_none") )]
	pub sys_id: Option<SystemIdentification2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DfltRsvatnTp", skip_serializing_if = "Option::is_none") )]
	pub dflt_rsvatn_tp: Option<Vec<ReservationType2Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CurRsvatnTp", skip_serializing_if = "Option::is_none") )]
	pub cur_rsvatn_tp: Option<Vec<ReservationType2Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctOwnr", skip_serializing_if = "Option::is_none") )]
	pub acct_ownr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctId", skip_serializing_if = "Option::is_none") )]
	pub acct_id: Option<AccountIdentification4Choice>,
}

impl ReservationSearchCriteria6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.dt_tm { val.validate()? }
		if let Some(ref val) = self.sys_id { val.validate()? }
		if let Some(ref vec) = self.dflt_rsvatn_tp { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.cur_rsvatn_tp { for item in vec { item.validate()? } }
		if let Some(ref val) = self.acct_ownr { val.validate()? }
		if let Some(ref val) = self.acct_id { val.validate()? }
		Ok(())
	}
}


// ReservationStatus1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReservationStatus1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<ReservationStatus1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl ReservationStatus1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// ReservationStatus1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ReservationStatus1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ENAB") )]
	CodeENAB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DISA") )]
	CodeDISA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DELD") )]
	CodeDELD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REQD") )]
	CodeREQD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BLKD") )]
	CodeBLKD,
}

impl ReservationStatus1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ReservationType2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReservationType2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl ReservationType2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// ResetDateAndValue1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ResetDateAndValue1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dt") )]
	pub dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val", skip_serializing_if = "Option::is_none") )]
	pub val: Option<f64>,
}

impl ResetDateAndValue1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ResidenceLocation1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ResidenceLocation1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctry", skip_serializing_if = "Option::is_none") )]
	pub ctry: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Area", skip_serializing_if = "Option::is_none") )]
	pub area: Option<String>,
}

impl ResidenceLocation1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ctry {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.area {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "area is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "area exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// ResidenceType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ResidenceType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "DMST") )]
	CodeDMST,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FRGN") )]
	CodeFRGN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MXED") )]
	CodeMXED,
}

impl ResidenceType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ResidentialStatus1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ResidentialStatus1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "RESI") )]
	CodeRESI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRES") )]
	CodePRES,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NRES") )]
	CodeNRES,
}

impl ResidentialStatus1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ResolutionData5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ResolutionData5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndToEndId", skip_serializing_if = "Option::is_none") )]
	pub end_to_end_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxId", skip_serializing_if = "Option::is_none") )]
	pub tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UETR", skip_serializing_if = "Option::is_none") )]
	pub uetr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBkSttlmAmt", skip_serializing_if = "Option::is_none") )]
	pub intr_bk_sttlm_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBkSttlmDt", skip_serializing_if = "Option::is_none") )]
	pub intr_bk_sttlm_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrChanl", skip_serializing_if = "Option::is_none") )]
	pub clr_chanl: Option<ClearingChannel2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Compstn", skip_serializing_if = "Option::is_none") )]
	pub compstn: Option<Compensation5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsInf", skip_serializing_if = "Option::is_none") )]
	pub chrgs_inf: Option<Vec<Charges14>>,
}

impl ResolutionData5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.end_to_end_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "end_to_end_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "end_to_end_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.uetr {
			let pattern = Regex::new("[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "uetr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.intr_bk_sttlm_amt { val.validate()? }
		if let Some(ref val) = self.clr_chanl { val.validate()? }
		if let Some(ref val) = self.compstn { val.validate()? }
		if let Some(ref vec) = self.chrgs_inf { for item in vec { item.validate()? } }
		Ok(())
	}
}


// ResponseDetails1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ResponseDetails1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RspnCd") )]
	pub rspn_cd: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlDtls", skip_serializing_if = "Option::is_none") )]
	pub addtl_dtls: Option<String>,
}

impl ResponseDetails1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.rspn_cd.chars().count() < 1 {
			return Err(ValidationError::new(1001, "rspn_cd is shorter than the minimum length of 1".to_string()));
		}
		if self.rspn_cd.chars().count() > 35 {
			return Err(ValidationError::new(1002, "rspn_cd exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.addtl_dtls {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_dtls is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "addtl_dtls exceeds the maximum length of 350".to_string()));
			}
		}
		Ok(())
	}
}


// Restriction1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Restriction1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RstrctnTp") )]
	pub rstrctn_tp: CodeOrProprietary1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldFr") )]
	pub vld_fr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldUntil", skip_serializing_if = "Option::is_none") )]
	pub vld_until: Option<String>,
}

impl Restriction1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.rstrctn_tp.validate()?;
		Ok(())
	}
}


// RestrictionModification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RestrictionModification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModCd", skip_serializing_if = "Option::is_none") )]
	pub mod_cd: Option<Modification1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rstrctn") )]
	pub rstrctn: Restriction1,
}

impl RestrictionModification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mod_cd { val.validate()? }
		self.rstrctn.validate()?;
		Ok(())
	}
}


// RestrictionStatus1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RestrictionStatus1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<RestrictionStatus1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl RestrictionStatus1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// RestrictionStatus1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum RestrictionStatus1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACTV") )]
	CodeACTV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INAC") )]
	CodeINAC,
}

impl RestrictionStatus1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// RestrictionType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum RestrictionType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "SELR") )]
	CodeSELR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BUYR") )]
	CodeBUYR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PLAR") )]
	CodePLAR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HOLR") )]
	CodeHOLR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VOTR") )]
	CodeVOTR,
}

impl RestrictionType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ReturnIndicator2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReturnIndicator2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RspnPrd", skip_serializing_if = "Option::is_none") )]
	pub rspn_prd: Option<DateOrDateTimePeriod1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AuthrtyReqTp") )]
	pub authrty_req_tp: AuthorityRequestType1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstgtnRslt") )]
	pub invstgtn_rslt: InvestigationResult1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
}

impl ReturnIndicator2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rspn_prd { val.validate()? }
		self.authrty_req_tp.validate()?;
		self.invstgtn_rslt.validate()?;
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 500 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 500".to_string()));
			}
		}
		Ok(())
	}
}


// ReturnReason5Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReturnReason5Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl ReturnReason5Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// ReuseDataReport6Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReuseDataReport6Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "New", skip_serializing_if = "Option::is_none") )]
	pub new: Option<ReuseDataReportNew6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Err", skip_serializing_if = "Option::is_none") )]
	pub err: Option<ReuseDataReportError5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Crrctn", skip_serializing_if = "Option::is_none") )]
	pub crrctn: Option<ReuseDataReportCorrection14>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollReuseUpd", skip_serializing_if = "Option::is_none") )]
	pub coll_reuse_upd: Option<ReuseDataReportCorrection14>,
}

impl ReuseDataReport6Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.new { val.validate()? }
		if let Some(ref val) = self.err { val.validate()? }
		if let Some(ref val) = self.crrctn { val.validate()? }
		if let Some(ref val) = self.coll_reuse_upd { val.validate()? }
		Ok(())
	}
}


// ReuseDataReportCorrection14 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReuseDataReportCorrection14 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechRcrdId", skip_serializing_if = "Option::is_none") )]
	pub tech_rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgDtTm") )]
	pub rptg_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPty") )]
	pub ctr_pty: CounterpartyData87,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollCmpnt", skip_serializing_if = "Option::is_none") )]
	pub coll_cmpnt: Option<Vec<CollateralType19>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EvtDay") )]
	pub evt_day: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FndgSrc", skip_serializing_if = "Option::is_none") )]
	pub fndg_src: Option<Vec<FundingSource3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl ReuseDataReportCorrection14 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tech_rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tech_rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "tech_rcrd_id exceeds the maximum length of 140".to_string()));
			}
		}
		self.ctr_pty.validate()?;
		if let Some(ref vec) = self.coll_cmpnt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.fndg_src { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// ReuseDataReportCorrection15 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReuseDataReportCorrection15 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechRcrdId", skip_serializing_if = "Option::is_none") )]
	pub tech_rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPty") )]
	pub ctr_pty: CounterpartyData87,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollCmpnt", skip_serializing_if = "Option::is_none") )]
	pub coll_cmpnt: Option<Vec<CollateralType19>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EvtDay") )]
	pub evt_day: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgDtTm") )]
	pub rptg_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FndgSrc", skip_serializing_if = "Option::is_none") )]
	pub fndg_src: Option<Vec<FundingSource3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RcncltnFlg", skip_serializing_if = "Option::is_none") )]
	pub rcncltn_flg: Option<ReconciliationFlag2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctMod") )]
	pub ctrct_mod: ContractModification3,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl ReuseDataReportCorrection15 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tech_rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tech_rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "tech_rcrd_id exceeds the maximum length of 140".to_string()));
			}
		}
		self.ctr_pty.validate()?;
		if let Some(ref vec) = self.coll_cmpnt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.fndg_src { for item in vec { item.validate()? } }
		if let Some(ref val) = self.rcncltn_flg { val.validate()? }
		self.ctrct_mod.validate()?;
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// ReuseDataReportError5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReuseDataReportError5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechRcrdId", skip_serializing_if = "Option::is_none") )]
	pub tech_rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgDtTm") )]
	pub rptg_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPty") )]
	pub ctr_pty: CounterpartyData87,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl ReuseDataReportError5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tech_rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tech_rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "tech_rcrd_id exceeds the maximum length of 140".to_string()));
			}
		}
		self.ctr_pty.validate()?;
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// ReuseDataReportNew6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReuseDataReportNew6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechRcrdId", skip_serializing_if = "Option::is_none") )]
	pub tech_rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgDtTm") )]
	pub rptg_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPty") )]
	pub ctr_pty: CounterpartyData87,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollCmpnt", skip_serializing_if = "Option::is_none") )]
	pub coll_cmpnt: Option<Vec<CollateralType19>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EvtDay") )]
	pub evt_day: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FndgSrc", skip_serializing_if = "Option::is_none") )]
	pub fndg_src: Option<Vec<FundingSource3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl ReuseDataReportNew6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tech_rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tech_rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "tech_rcrd_id exceeds the maximum length of 140".to_string()));
			}
		}
		self.ctr_pty.validate()?;
		if let Some(ref vec) = self.coll_cmpnt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.fndg_src { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// ReuseValue1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReuseValue1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Actl", skip_serializing_if = "Option::is_none") )]
	pub actl: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Estmtd", skip_serializing_if = "Option::is_none") )]
	pub estmtd: Option<ActiveOrHistoricCurrencyAndAmount>,
}

impl ReuseValue1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.actl { val.validate()? }
		if let Some(ref val) = self.estmtd { val.validate()? }
		Ok(())
	}
}


// ReversalReason4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ReversalReason4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl ReversalReason4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// RiskFactor1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RiskFactor1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StrssSz") )]
	pub strss_sz: StressSize1Choice,
}

impl RiskFactor1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		self.strss_sz.validate()?;
		Ok(())
	}
}


// RiskLevel1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum RiskLevel1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "HIGH") )]
	CodeHIGH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LOWW") )]
	CodeLOWW,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MEDM") )]
	CodeMEDM,
}

impl RiskLevel1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// RiskLevel2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RiskLevel2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<RiskLevel1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl RiskLevel2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// RiskReductionService1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum RiskReductionService1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "NORR") )]
	CodeNORR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PWOS") )]
	CodePWOS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRBM") )]
	CodePRBM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PWAS") )]
	CodePWAS,
}

impl RiskReductionService1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// RiskTolerance1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RiskTolerance1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RskTlrncePRIIPSMthdlgy", skip_serializing_if = "Option::is_none") )]
	pub rsk_tlrnce_priips_mthdlgy: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RskTlrnceUCITSMthdlgy", skip_serializing_if = "Option::is_none") )]
	pub rsk_tlrnce_ucits_mthdlgy: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RskTlrnceIntl", skip_serializing_if = "Option::is_none") )]
	pub rsk_tlrnce_intl: Option<RiskLevel1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RskTlrnceForNonPRIIPSAndNonUCITSES", skip_serializing_if = "Option::is_none") )]
	pub rsk_tlrnce_for_non_priips_and_non_ucitses: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NotForInvstrsWthTheLwstRskTlrnceDE", skip_serializing_if = "Option::is_none") )]
	pub not_for_invstrs_wth_the_lwst_rsk_tlrnce_de: Option<TargetMarket2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<Vec<OtherTargetMarketRiskTolerance1>>,
}

impl RiskTolerance1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rsk_tlrnce_intl { val.validate()? }
		if let Some(ref val) = self.not_for_invstrs_wth_the_lwst_rsk_tlrnce_de { val.validate()? }
		if let Some(ref vec) = self.othr { for item in vec { item.validate()? } }
		Ok(())
	}
}


// RoundingDirection1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum RoundingDirection1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "RDUP") )]
	CodeRDUP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RDWN") )]
	CodeRDWN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "STAN") )]
	CodeSTAN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DIST") )]
	CodeDIST,
}

impl RoundingDirection1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// RoundingDirection2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum RoundingDirection2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "RDUP") )]
	CodeRDUP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RDWN") )]
	CodeRDWN,
}

impl RoundingDirection2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// RoundingParameters1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct RoundingParameters1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RndgMdlus", skip_serializing_if = "Option::is_none") )]
	pub rndg_mdlus: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RndgDrctn") )]
	pub rndg_drctn: RoundingDirection1Code,
}

impl RoundingParameters1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.rndg_drctn.validate()?;
		Ok(())
	}
}


// ScenarioDefinition2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ScenarioDefinition2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: GenericIdentification165,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ScnroTp") )]
	pub scnro_tp: ScenarioType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StrtgyStrssTp") )]
	pub strtgy_strss_tp: StrategyStressType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StrssItm") )]
	pub strss_itm: Vec<StressItem1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Desc", skip_serializing_if = "Option::is_none") )]
	pub desc: Option<String>,
}

impl ScenarioDefinition2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.id.validate()?;
		self.scnro_tp.validate()?;
		self.strtgy_strss_tp.validate()?;
		for item in &self.strss_itm { item.validate()? }
		if let Some(ref val) = self.desc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "desc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 2000 {
				return Err(ValidationError::new(1002, "desc exceeds the maximum length of 2000".to_string()));
			}
		}
		Ok(())
	}
}


// ScenarioStressTestResult1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ScenarioStressTestResult1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: GenericIdentification168,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtflStrssTstRslt") )]
	pub prtfl_strss_tst_rslt: Vec<PortfolioStressTestResult1>,
}

impl ScenarioStressTestResult1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.id.validate()?;
		for item in &self.prtfl_strss_tst_rslt { item.validate()? }
		Ok(())
	}
}


// ScenarioType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ScenarioType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "HIST") )]
	CodeHIST,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HYPT") )]
	CodeHYPT,
}

impl ScenarioType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Schedule1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Schedule1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "UadjstdFctvDt") )]
	pub uadjstd_fctv_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UadjstdEndDt", skip_serializing_if = "Option::is_none") )]
	pub uadjstd_end_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pric") )]
	pub pric: SecuritiesTransactionPrice17Choice,
}

impl Schedule1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pric.validate()?;
		Ok(())
	}
}


// Schedule10 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Schedule10 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Qty") )]
	pub qty: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnitOfMeasr", skip_serializing_if = "Option::is_none") )]
	pub unit_of_measr: Option<UnitOfMeasure8Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UadjstdFctvDt") )]
	pub uadjstd_fctv_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UadjstdEndDt", skip_serializing_if = "Option::is_none") )]
	pub uadjstd_end_dt: Option<String>,
}

impl Schedule10 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.unit_of_measr { val.validate()? }
		Ok(())
	}
}


// Schedule11 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Schedule11 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "UadjstdFctvDt") )]
	pub uadjstd_fctv_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UadjstdEndDt", skip_serializing_if = "Option::is_none") )]
	pub uadjstd_end_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: AmountAndDirection106,
}

impl Schedule11 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.amt.validate()?;
		Ok(())
	}
}


// Schedule4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Schedule4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "UadjstdFctvDt") )]
	pub uadjstd_fctv_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UadjstdEndDt", skip_serializing_if = "Option::is_none") )]
	pub uadjstd_end_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pric") )]
	pub pric: SecuritiesTransactionPrice17Choice,
}

impl Schedule4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pric.validate()?;
		Ok(())
	}
}


// SchemeIdentificationType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum SchemeIdentificationType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "MARG") )]
	CodeMARG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "COLL") )]
	CodeCOLL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "POSI") )]
	CodePOSI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CLIM") )]
	CodeCLIM,
}

impl SchemeIdentificationType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SearchCriteria2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SearchCriteria2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Acct", skip_serializing_if = "Option::is_none") )]
	pub acct: Option<AccountAndParties3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CstmrId", skip_serializing_if = "Option::is_none") )]
	pub cstmr_id: Option<CustomerIdentification2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtInstrm", skip_serializing_if = "Option::is_none") )]
	pub pmt_instrm: Option<PaymentInstrumentType1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlTxNb", skip_serializing_if = "Option::is_none") )]
	pub orgnl_tx_nb: Option<Vec<RequestType1>>,
}

impl SearchCriteria2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.acct { val.validate()? }
		if let Some(ref val) = self.cstmr_id { val.validate()? }
		if let Some(ref val) = self.pmt_instrm { val.validate()? }
		if let Some(ref vec) = self.orgnl_tx_nb { for item in vec { item.validate()? } }
		Ok(())
	}
}


// SectorAndLocation1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SectorAndLocation1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sctr") )]
	pub sctr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Lctn") )]
	pub lctn: String,
}

impl SectorAndLocation1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{2,2}").unwrap();
		if !pattern.is_match(&self.lctn) {
			return Err(ValidationError::new(1005, "lctn does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// SecuredCollateral2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuredCollateral2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SnglColl", skip_serializing_if = "Option::is_none") )]
	pub sngl_coll: Option<CollateralValuation6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MltplColl", skip_serializing_if = "Option::is_none") )]
	pub mltpl_coll: Option<Vec<CollateralValuation6>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PoolColl", skip_serializing_if = "Option::is_none") )]
	pub pool_coll: Option<CollateralValuation6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrColl", skip_serializing_if = "Option::is_none") )]
	pub othr_coll: Option<Vec<CollateralValuation7>>,
}

impl SecuredCollateral2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.sngl_coll { val.validate()? }
		if let Some(ref vec) = self.mltpl_coll { for item in vec { item.validate()? } }
		if let Some(ref val) = self.pool_coll { val.validate()? }
		if let Some(ref vec) = self.othr_coll { for item in vec { item.validate()? } }
		Ok(())
	}
}


// SecuredMarketReport4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuredMarketReport4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DataSetActn", skip_serializing_if = "Option::is_none") )]
	pub data_set_actn: Option<ReportPeriodActivity3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tx", skip_serializing_if = "Option::is_none") )]
	pub tx: Option<Vec<SecuredMarketTransaction4>>,
}

impl SecuredMarketReport4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.data_set_actn { val.validate()? }
		if let Some(ref vec) = self.tx { for item in vec { item.validate()? } }
		Ok(())
	}
}


// SecuredMarketTransaction4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuredMarketTransaction4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptdTxSts") )]
	pub rptd_tx_sts: TransactionOperationType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NvtnSts", skip_serializing_if = "Option::is_none") )]
	pub nvtn_sts: Option<NovationStatus1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BrnchId", skip_serializing_if = "Option::is_none") )]
	pub brnch_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnqTxIdr", skip_serializing_if = "Option::is_none") )]
	pub unq_tx_idr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtryTxId") )]
	pub prtry_tx_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdPrtryTxId", skip_serializing_if = "Option::is_none") )]
	pub rltd_prtry_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtyPrtryTxId", skip_serializing_if = "Option::is_none") )]
	pub ctr_pty_prtry_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtyId") )]
	pub ctr_pty_id: CounterpartyIdentification3Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrptyAgtId", skip_serializing_if = "Option::is_none") )]
	pub trpty_agt_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradDt") )]
	pub trad_dt: DateAndDateTimeChoice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmDt") )]
	pub sttlm_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MtrtyDt") )]
	pub mtrty_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxTp") )]
	pub tx_tp: MoneyMarketTransactionType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxNmnlAmt") )]
	pub tx_nmnl_amt: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RateTp") )]
	pub rate_tp: InterestRateType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DealRate", skip_serializing_if = "Option::is_none") )]
	pub deal_rate: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FltgRateRpAgrmt", skip_serializing_if = "Option::is_none") )]
	pub fltg_rate_rp_agrmt: Option<FloatingRateNote2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BrkrdDeal", skip_serializing_if = "Option::is_none") )]
	pub brkrd_deal: Option<BrokeredDeal1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Coll") )]
	pub coll: Collateral18,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl SecuredMarketTransaction4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.rptd_tx_sts.validate()?;
		if let Some(ref val) = self.nvtn_sts { val.validate()? }
		if let Some(ref val) = self.brnch_id {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "brnch_id does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.unq_tx_idr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "unq_tx_idr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 105 {
				return Err(ValidationError::new(1002, "unq_tx_idr exceeds the maximum length of 105".to_string()));
			}
		}
		if self.prtry_tx_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "prtry_tx_id is shorter than the minimum length of 1".to_string()));
		}
		if self.prtry_tx_id.chars().count() > 105 {
			return Err(ValidationError::new(1002, "prtry_tx_id exceeds the maximum length of 105".to_string()));
		}
		if let Some(ref val) = self.rltd_prtry_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rltd_prtry_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 105 {
				return Err(ValidationError::new(1002, "rltd_prtry_tx_id exceeds the maximum length of 105".to_string()));
			}
		}
		if let Some(ref val) = self.ctr_pty_prtry_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ctr_pty_prtry_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 105 {
				return Err(ValidationError::new(1002, "ctr_pty_prtry_tx_id exceeds the maximum length of 105".to_string()));
			}
		}
		self.ctr_pty_id.validate()?;
		if let Some(ref val) = self.trpty_agt_id {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "trpty_agt_id does not match the required pattern".to_string()));
			}
		}
		self.trad_dt.validate()?;
		self.tx_tp.validate()?;
		self.tx_nmnl_amt.validate()?;
		self.rate_tp.validate()?;
		if let Some(ref val) = self.fltg_rate_rp_agrmt { val.validate()? }
		if let Some(ref val) = self.brkrd_deal { val.validate()? }
		self.coll.validate()?;
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// SecuritiesAccount19 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesAccount19 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<GenericIdentification30>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
}

impl SecuritiesAccount19 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 70".to_string()));
			}
		}
		Ok(())
	}
}


// SecuritiesAccount22 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesAccount22 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<GenericIdentification30>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
}

impl SecuritiesAccount22 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 70 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 70".to_string()));
			}
		}
		Ok(())
	}
}


// SecuritiesAccountAuditTrailOrOperationalError3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesAccountAuditTrailOrOperationalError3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctiesAcctAudtTrlRpt", skip_serializing_if = "Option::is_none") )]
	pub scties_acct_audt_trl_rpt: Option<Vec<SecuritiesAccountAuditTrailReport3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OprlErr", skip_serializing_if = "Option::is_none") )]
	pub oprl_err: Option<Vec<ErrorHandling5>>,
}

impl SecuritiesAccountAuditTrailOrOperationalError3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.scties_acct_audt_trl_rpt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.oprl_err { for item in vec { item.validate()? } }
		Ok(())
	}
}


// SecuritiesAccountAuditTrailReport3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesAccountAuditTrailReport3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctiesAcctAudtTrlOrErr") )]
	pub scties_acct_audt_trl_or_err: AuditTrailOrBusinessError6Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtPrd", skip_serializing_if = "Option::is_none") )]
	pub dt_prd: Option<DatePeriodSearch1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctiesAcctId") )]
	pub scties_acct_id: SecuritiesAccount19,
}

impl SecuritiesAccountAuditTrailReport3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.scties_acct_audt_trl_or_err.validate()?;
		if let Some(ref val) = self.dt_prd { val.validate()? }
		self.scties_acct_id.validate()?;
		Ok(())
	}
}


// SecuritiesAccountAuditTrailSearchCriteria3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesAccountAuditTrailSearchCriteria3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctiesAcctId", skip_serializing_if = "Option::is_none") )]
	pub scties_acct_id: Option<SecuritiesAccount19>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtPrd", skip_serializing_if = "Option::is_none") )]
	pub dt_prd: Option<DatePeriodSearch1Choice>,
}

impl SecuritiesAccountAuditTrailSearchCriteria3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.scties_acct_id { val.validate()? }
		if let Some(ref val) = self.dt_prd { val.validate()? }
		Ok(())
	}
}


// SecuritiesAccountModification2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesAccountModification2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ScpIndctn") )]
	pub scp_indctn: DataModification1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdMod") )]
	pub reqd_mod: SecuritiesAccountModification2Choice,
}

impl SecuritiesAccountModification2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.scp_indctn.validate()?;
		self.reqd_mod.validate()?;
		Ok(())
	}
}


// SecuritiesAccountModification2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesAccountModification2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SysSctiesAcct", skip_serializing_if = "Option::is_none") )]
	pub sys_scties_acct: Option<SystemSecuritiesAccount5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SysRstrctn", skip_serializing_if = "Option::is_none") )]
	pub sys_rstrctn: Option<SystemRestriction1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktSpcfcAttr", skip_serializing_if = "Option::is_none") )]
	pub mkt_spcfc_attr: Option<MarketSpecificAttribute1>,
}

impl SecuritiesAccountModification2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.sys_scties_acct { val.validate()? }
		if let Some(ref val) = self.sys_rstrctn { val.validate()? }
		if let Some(ref val) = self.mkt_spcfc_attr { val.validate()? }
		Ok(())
	}
}


// SecuritiesAccountOrBusinessError3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesAccountOrBusinessError3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctiesAcct", skip_serializing_if = "Option::is_none") )]
	pub scties_acct: Option<SystemSecuritiesAccount6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizErr", skip_serializing_if = "Option::is_none") )]
	pub biz_err: Option<Vec<ErrorHandling5>>,
}

impl SecuritiesAccountOrBusinessError3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.scties_acct { val.validate()? }
		if let Some(ref vec) = self.biz_err { for item in vec { item.validate()? } }
		Ok(())
	}
}


// SecuritiesAccountOrOperationalError3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesAccountOrOperationalError3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctiesAcctRpt", skip_serializing_if = "Option::is_none") )]
	pub scties_acct_rpt: Option<Vec<SecuritiesAccountReport3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OprlErr", skip_serializing_if = "Option::is_none") )]
	pub oprl_err: Option<Vec<ErrorHandling5>>,
}

impl SecuritiesAccountOrOperationalError3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.scties_acct_rpt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.oprl_err { for item in vec { item.validate()? } }
		Ok(())
	}
}


// SecuritiesAccountReferenceDataChange2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesAccountReferenceDataChange2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctiesAcctId") )]
	pub scties_acct_id: SecuritiesAccount19,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FldNm") )]
	pub fld_nm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OdFldVal") )]
	pub od_fld_val: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NewFldVal") )]
	pub new_fld_val: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OprTmStmp") )]
	pub opr_tm_stmp: String,
}

impl SecuritiesAccountReferenceDataChange2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.scties_acct_id.validate()?;
		if self.fld_nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "fld_nm is shorter than the minimum length of 1".to_string()));
		}
		if self.fld_nm.chars().count() > 35 {
			return Err(ValidationError::new(1002, "fld_nm exceeds the maximum length of 35".to_string()));
		}
		if self.od_fld_val.chars().count() < 1 {
			return Err(ValidationError::new(1001, "od_fld_val is shorter than the minimum length of 1".to_string()));
		}
		if self.od_fld_val.chars().count() > 350 {
			return Err(ValidationError::new(1002, "od_fld_val exceeds the maximum length of 350".to_string()));
		}
		if self.new_fld_val.chars().count() < 1 {
			return Err(ValidationError::new(1001, "new_fld_val is shorter than the minimum length of 1".to_string()));
		}
		if self.new_fld_val.chars().count() > 350 {
			return Err(ValidationError::new(1002, "new_fld_val exceeds the maximum length of 350".to_string()));
		}
		Ok(())
	}
}


// SecuritiesAccountReport3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesAccountReport3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctiesAcctId") )]
	pub scties_acct_id: SecuritiesAccount19,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctiesAcctOrErr") )]
	pub scties_acct_or_err: SecuritiesAccountOrBusinessError3Choice,
}

impl SecuritiesAccountReport3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.scties_acct_id.validate()?;
		self.scties_acct_or_err.validate()?;
		Ok(())
	}
}


// SecuritiesAccountReturnCriteria1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesAccountReturnCriteria1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctId", skip_serializing_if = "Option::is_none") )]
	pub acct_id: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtyId", skip_serializing_if = "Option::is_none") )]
	pub pty_id: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtyTp", skip_serializing_if = "Option::is_none") )]
	pub pty_tp: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcr", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctTp", skip_serializing_if = "Option::is_none") )]
	pub acct_tp: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OpngDt", skip_serializing_if = "Option::is_none") )]
	pub opng_dt: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClsgDt", skip_serializing_if = "Option::is_none") )]
	pub clsg_dt: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndInvstrFlg", skip_serializing_if = "Option::is_none") )]
	pub end_invstr_flg: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PricgSchme", skip_serializing_if = "Option::is_none") )]
	pub pricg_schme: Option<bool>,
}

impl SecuritiesAccountReturnCriteria1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SecuritiesAccountSearchCriteria2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesAccountSearchCriteria2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctId", skip_serializing_if = "Option::is_none") )]
	pub acct_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcr", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr: Option<PartyIdentification136>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctOwnr", skip_serializing_if = "Option::is_none") )]
	pub acct_ownr: Option<SystemPartyIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtyTp", skip_serializing_if = "Option::is_none") )]
	pub pty_tp: Option<SystemPartyType1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OpngDt", skip_serializing_if = "Option::is_none") )]
	pub opng_dt: Option<DatePeriodSearch1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClsgDt", skip_serializing_if = "Option::is_none") )]
	pub clsg_dt: Option<DatePeriodSearch1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctTp", skip_serializing_if = "Option::is_none") )]
	pub acct_tp: Option<SystemSecuritiesAccountType1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndInvstrFlg", skip_serializing_if = "Option::is_none") )]
	pub end_invstr_flg: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PricgSchme", skip_serializing_if = "Option::is_none") )]
	pub pricg_schme: Option<String>,
}

impl SecuritiesAccountSearchCriteria2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.acct_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acct_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.acct_svcr { val.validate()? }
		if let Some(ref val) = self.acct_ownr { val.validate()? }
		if let Some(ref val) = self.pty_tp { val.validate()? }
		if let Some(ref val) = self.opng_dt { val.validate()? }
		if let Some(ref val) = self.clsg_dt { val.validate()? }
		if let Some(ref val) = self.acct_tp { val.validate()? }
		if let Some(ref val) = self.end_invstr_flg {
			let pattern = Regex::new("[a-zA-Z0-9]{4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "end_invstr_flg does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.pricg_schme {
			let pattern = Regex::new("[a-zA-Z0-9]{4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "pricg_schme does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// SecuritiesAccountStatement2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesAccountStatement2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SysDt") )]
	pub sys_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Chng", skip_serializing_if = "Option::is_none") )]
	pub chng: Option<Vec<SecuritiesAccountReferenceDataChange2>>,
}

impl SecuritiesAccountStatement2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.chng { for item in vec { item.validate()? } }
		Ok(())
	}
}


// SecuritiesAccountStatus2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesAccountStatus2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdSctiesAcct", skip_serializing_if = "Option::is_none") )]
	pub rltd_scties_acct: Option<SecuritiesAccount19>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts") )]
	pub sts: Status6Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsRsn", skip_serializing_if = "Option::is_none") )]
	pub sts_rsn: Option<Vec<StatusReasonInformation10>>,
}

impl SecuritiesAccountStatus2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rltd_scties_acct { val.validate()? }
		self.sts.validate()?;
		if let Some(ref vec) = self.sts_rsn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// SecuritiesAuditTrailOrOperationalError4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesAuditTrailOrOperationalError4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctiesAudtTrlRpt", skip_serializing_if = "Option::is_none") )]
	pub scties_audt_trl_rpt: Option<Vec<SecuritiesAuditTrailReport4>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OprlErr", skip_serializing_if = "Option::is_none") )]
	pub oprl_err: Option<Vec<ErrorHandling5>>,
}

impl SecuritiesAuditTrailOrOperationalError4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.scties_audt_trl_rpt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.oprl_err { for item in vec { item.validate()? } }
		Ok(())
	}
}


// SecuritiesAuditTrailReport4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesAuditTrailReport4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctiesAudtTrlOrErr") )]
	pub scties_audt_trl_or_err: AuditTrailOrBusinessError6Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtPrd", skip_serializing_if = "Option::is_none") )]
	pub dt_prd: Option<DatePeriodSearch1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmId") )]
	pub fin_instrm_id: SecurityIdentification39,
}

impl SecuritiesAuditTrailReport4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.scties_audt_trl_or_err.validate()?;
		if let Some(ref val) = self.dt_prd { val.validate()? }
		self.fin_instrm_id.validate()?;
		Ok(())
	}
}


// SecuritiesAuditTrailSearchCriteria4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesAuditTrailSearchCriteria4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmId", skip_serializing_if = "Option::is_none") )]
	pub fin_instrm_id: Option<SecurityIdentification39>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtPrd", skip_serializing_if = "Option::is_none") )]
	pub dt_prd: Option<DatePeriodSearch1Choice>,
}

impl SecuritiesAuditTrailSearchCriteria4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.fin_instrm_id { val.validate()? }
		if let Some(ref val) = self.dt_prd { val.validate()? }
		Ok(())
	}
}


// SecuritiesCountryIdentification2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesCountryIdentification2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctry") )]
	pub ctry: CountryCodeAndName3,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EEACtry") )]
	pub eea_ctry: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mod", skip_serializing_if = "Option::is_none") )]
	pub mod_attr: Option<Modification1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldtyPrd") )]
	pub vldty_prd: Period4Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LastUpdtd", skip_serializing_if = "Option::is_none") )]
	pub last_updtd: Option<String>,
}

impl SecuritiesCountryIdentification2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.ctry.validate()?;
		if let Some(ref val) = self.mod_attr { val.validate()? }
		self.vldty_prd.validate()?;
		Ok(())
	}
}


// SecuritiesCurrencyIdentification2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesCurrencyIdentification2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ccy") )]
	pub ccy: CurrencyCodeAndName1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrctnlDgt", skip_serializing_if = "Option::is_none") )]
	pub frctnl_dgt: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtryDtls") )]
	pub ctry_dtls: CountryCodeAndName3,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PreEuro") )]
	pub pre_euro: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mod", skip_serializing_if = "Option::is_none") )]
	pub mod_attr: Option<Modification1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldtyPrd") )]
	pub vldty_prd: Period4Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LastUpdtd", skip_serializing_if = "Option::is_none") )]
	pub last_updtd: Option<String>,
}

impl SecuritiesCurrencyIdentification2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.ccy.validate()?;
		self.ctry_dtls.validate()?;
		if let Some(ref val) = self.mod_attr { val.validate()? }
		self.vldty_prd.validate()?;
		Ok(())
	}
}


// SecuritiesIndexReport1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesIndexReport1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechRcrdId", skip_serializing_if = "Option::is_none") )]
	pub tech_rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RqstngNtty", skip_serializing_if = "Option::is_none") )]
	pub rqstng_ntty: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Indx") )]
	pub indx: FinancialInstrument46Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldtyPrd", skip_serializing_if = "Option::is_none") )]
	pub vldty_prd: Option<Period4Choice>,
}

impl SecuritiesIndexReport1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tech_rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tech_rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tech_rcrd_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.rqstng_ntty {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "rqstng_ntty does not match the required pattern".to_string()));
			}
		}
		self.indx.validate()?;
		if let Some(ref val) = self.vldty_prd { val.validate()? }
		Ok(())
	}
}


// SecuritiesInstrumentClassification2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesInstrumentClassification2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Idr") )]
	pub idr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mod", skip_serializing_if = "Option::is_none") )]
	pub mod_attr: Option<Modification1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldtyPrd") )]
	pub vldty_prd: Period4Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LastUpdtd", skip_serializing_if = "Option::is_none") )]
	pub last_updtd: Option<String>,
}

impl SecuritiesInstrumentClassification2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{6,6}").unwrap();
		if !pattern.is_match(&self.idr) {
			return Err(ValidationError::new(1005, "idr does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.mod_attr { val.validate()? }
		self.vldty_prd.validate()?;
		Ok(())
	}
}


// SecuritiesInvalidReferenceDataReport4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesInvalidReferenceDataReport4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrm") )]
	pub fin_instrm: SecuritiesReferenceDataReport6,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl SecuritiesInvalidReferenceDataReport4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.fin_instrm.validate()?;
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// SecuritiesLendingType3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesLendingType3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl SecuritiesLendingType3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// SecuritiesMarketReportHeader1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesMarketReportHeader1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgNtty") )]
	pub rptg_ntty: TradingVenueIdentification1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgPrd") )]
	pub rptg_prd: Period4Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubmissnDtTm", skip_serializing_if = "Option::is_none") )]
	pub submissn_dt_tm: Option<String>,
}

impl SecuritiesMarketReportHeader1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.rptg_ntty.validate()?;
		self.rptg_prd.validate()?;
		Ok(())
	}
}


// SecuritiesMarketReportHeader3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesMarketReportHeader3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgNtty") )]
	pub rptg_ntty: TradingVenueIdentification1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgPrd") )]
	pub rptg_prd: Period11Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISIN", skip_serializing_if = "Option::is_none") )]
	pub isin: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubmissnDtTm", skip_serializing_if = "Option::is_none") )]
	pub submissn_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgPgntn", skip_serializing_if = "Option::is_none") )]
	pub msg_pgntn: Option<Pagination1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbRcrds", skip_serializing_if = "Option::is_none") )]
	pub nb_rcrds: Option<f64>,
}

impl SecuritiesMarketReportHeader3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.rptg_ntty.validate()?;
		self.rptg_prd.validate()?;
		if let Some(ref vec) = self.isin {
			for item in vec {
				let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
				if !pattern.is_match(&item) {
					return Err(ValidationError::new(1005, "isin does not match the required pattern".to_string()));
				}
			}
		}
		if let Some(ref val) = self.msg_pgntn { val.validate()? }
		Ok(())
	}
}


// SecuritiesNonTradingDay1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesNonTradingDay1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechRcrdId", skip_serializing_if = "Option::is_none") )]
	pub tech_rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dt") )]
	pub dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<NonTradingDayReason1Code>,
}

impl SecuritiesNonTradingDay1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tech_rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tech_rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tech_rcrd_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.rsn { val.validate()? }
		Ok(())
	}
}


// SecuritiesNonTradingDayReport1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesNonTradingDayReport1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: TradingVenueIdentification1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NonWorkgDay") )]
	pub non_workg_day: Vec<SecuritiesNonTradingDay1>,
}

impl SecuritiesNonTradingDayReport1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.id.validate()?;
		for item in &self.non_workg_day { item.validate()? }
		Ok(())
	}
}


// SecuritiesOrCash1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesOrCash1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctiesDtls", skip_serializing_if = "Option::is_none") )]
	pub scties_dtls: Option<SettlementParties35>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshPtiesDtls", skip_serializing_if = "Option::is_none") )]
	pub csh_pties_dtls: Option<CashParties24>,
}

impl SecuritiesOrCash1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.scties_dtls { val.validate()? }
		if let Some(ref val) = self.csh_pties_dtls { val.validate()? }
		Ok(())
	}
}


// SecuritiesPaymentStatus1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum SecuritiesPaymentStatus1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "FULL") )]
	CodeFULL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NILL") )]
	CodeNILL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PART") )]
	CodePART,
}

impl SecuritiesPaymentStatus1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SecuritiesPaymentStatus5Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesPaymentStatus5Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<SecuritiesPaymentStatus1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl SecuritiesPaymentStatus5Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// SecuritiesReferenceDataChange3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesReferenceDataChange3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmId") )]
	pub fin_instrm_id: SecurityIdentification39,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FldNm") )]
	pub fld_nm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OdFldVal") )]
	pub od_fld_val: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NewFldVal") )]
	pub new_fld_val: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OprTmStmp") )]
	pub opr_tm_stmp: String,
}

impl SecuritiesReferenceDataChange3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.fin_instrm_id.validate()?;
		if self.fld_nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "fld_nm is shorter than the minimum length of 1".to_string()));
		}
		if self.fld_nm.chars().count() > 35 {
			return Err(ValidationError::new(1002, "fld_nm exceeds the maximum length of 35".to_string()));
		}
		if self.od_fld_val.chars().count() < 1 {
			return Err(ValidationError::new(1001, "od_fld_val is shorter than the minimum length of 1".to_string()));
		}
		if self.od_fld_val.chars().count() > 350 {
			return Err(ValidationError::new(1002, "od_fld_val exceeds the maximum length of 350".to_string()));
		}
		if self.new_fld_val.chars().count() < 1 {
			return Err(ValidationError::new(1001, "new_fld_val is shorter than the minimum length of 1".to_string()));
		}
		if self.new_fld_val.chars().count() > 350 {
			return Err(ValidationError::new(1002, "new_fld_val exceeds the maximum length of 350".to_string()));
		}
		Ok(())
	}
}


// SecuritiesReferenceDataReport6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesReferenceDataReport6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechRcrdId", skip_serializing_if = "Option::is_none") )]
	pub tech_rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmGnlAttrbts") )]
	pub fin_instrm_gnl_attrbts: SecurityInstrumentDescription9,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issr") )]
	pub issr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgVnRltdAttrbts") )]
	pub tradg_vn_rltd_attrbts: Vec<TradingVenueAttributes1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DebtInstrmAttrbts", skip_serializing_if = "Option::is_none") )]
	pub debt_instrm_attrbts: Option<DebtInstrument2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DerivInstrmAttrbts", skip_serializing_if = "Option::is_none") )]
	pub deriv_instrm_attrbts: Option<DerivativeInstrument5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechAttrbts", skip_serializing_if = "Option::is_none") )]
	pub tech_attrbts: Option<RecordTechnicalData4>,
}

impl SecuritiesReferenceDataReport6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tech_rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tech_rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tech_rcrd_id exceeds the maximum length of 35".to_string()));
			}
		}
		self.fin_instrm_gnl_attrbts.validate()?;
		let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
		if !pattern.is_match(&self.issr) {
			return Err(ValidationError::new(1005, "issr does not match the required pattern".to_string()));
		}
		for item in &self.tradg_vn_rltd_attrbts { item.validate()? }
		if let Some(ref val) = self.debt_instrm_attrbts { val.validate()? }
		if let Some(ref val) = self.deriv_instrm_attrbts { val.validate()? }
		if let Some(ref val) = self.tech_attrbts { val.validate()? }
		Ok(())
	}
}


// SecuritiesReferenceDataReport7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesReferenceDataReport7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechRcrdId", skip_serializing_if = "Option::is_none") )]
	pub tech_rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmGnlAttrbts") )]
	pub fin_instrm_gnl_attrbts: SecurityInstrumentDescription17,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issr", skip_serializing_if = "Option::is_none") )]
	pub issr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgVnRltdAttrbts") )]
	pub tradg_vn_rltd_attrbts: Vec<TradingVenueAttributes2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DebtInstrmAttrbts", skip_serializing_if = "Option::is_none") )]
	pub debt_instrm_attrbts: Option<DebtInstrument2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DerivInstrmAttrbts", skip_serializing_if = "Option::is_none") )]
	pub deriv_instrm_attrbts: Option<DerivativeInstrument5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechAttrbts", skip_serializing_if = "Option::is_none") )]
	pub tech_attrbts: Option<RecordTechnicalData4>,
}

impl SecuritiesReferenceDataReport7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tech_rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tech_rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tech_rcrd_id exceeds the maximum length of 35".to_string()));
			}
		}
		self.fin_instrm_gnl_attrbts.validate()?;
		if let Some(ref val) = self.issr {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "issr does not match the required pattern".to_string()));
			}
		}
		for item in &self.tradg_vn_rltd_attrbts { item.validate()? }
		if let Some(ref val) = self.debt_instrm_attrbts { val.validate()? }
		if let Some(ref val) = self.deriv_instrm_attrbts { val.validate()? }
		if let Some(ref val) = self.tech_attrbts { val.validate()? }
		Ok(())
	}
}


// SecuritiesReferenceDeltaStatusReport5Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesReferenceDeltaStatusReport5Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModfdRcrd", skip_serializing_if = "Option::is_none") )]
	pub modfd_rcrd: Option<SecuritiesReferenceDataReport6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NewRcrd", skip_serializing_if = "Option::is_none") )]
	pub new_rcrd: Option<SecuritiesReferenceDataReport6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TermntdRcrd", skip_serializing_if = "Option::is_none") )]
	pub termntd_rcrd: Option<SecuritiesReferenceDataReport6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CancRcrd", skip_serializing_if = "Option::is_none") )]
	pub canc_rcrd: Option<SecuritiesReferenceDataReport7>,
}

impl SecuritiesReferenceDeltaStatusReport5Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.modfd_rcrd { val.validate()? }
		if let Some(ref val) = self.new_rcrd { val.validate()? }
		if let Some(ref val) = self.termntd_rcrd { val.validate()? }
		if let Some(ref val) = self.canc_rcrd { val.validate()? }
		Ok(())
	}
}


// SecuritiesReturnCriteria1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesReturnCriteria1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmId") )]
	pub fin_instrm_id: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISOSctyLngNm") )]
	pub iso_scty_lng_nm: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISOSctyShrtNm") )]
	pub iso_scty_shrt_nm: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClssfctnFinInstrm") )]
	pub clssfctn_fin_instrm: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MtrtyDt") )]
	pub mtrty_dt: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IsseDt") )]
	pub isse_dt: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IsseCcy") )]
	pub isse_ccy: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtryOfIsse") )]
	pub ctry_of_isse: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctySts") )]
	pub scty_sts: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstrCSD") )]
	pub invstr_csd: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IssrCSD") )]
	pub issr_csd: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechIssrCSD") )]
	pub tech_issr_csd: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CSD") )]
	pub csd: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctiesQtyTp") )]
	pub scties_qty_tp: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MinDnmtn") )]
	pub min_dnmtn: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MinMltplQty") )]
	pub min_mltpl_qty: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DevtgSttlmUnit") )]
	pub devtg_sttlm_unit: bool,
}

impl SecuritiesReturnCriteria1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SecuritiesSearchCriteria4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesSearchCriteria4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmId", skip_serializing_if = "Option::is_none") )]
	pub fin_instrm_id: Option<SecurityIdentification39>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClssfctnFinInstrm", skip_serializing_if = "Option::is_none") )]
	pub clssfctn_fin_instrm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MtrtyDt", skip_serializing_if = "Option::is_none") )]
	pub mtrty_dt: Option<DatePeriodSearch1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IsseDt", skip_serializing_if = "Option::is_none") )]
	pub isse_dt: Option<DatePeriodSearch1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IsseCcy", skip_serializing_if = "Option::is_none") )]
	pub isse_ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtryOfIsse", skip_serializing_if = "Option::is_none") )]
	pub ctry_of_isse: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctySts", skip_serializing_if = "Option::is_none") )]
	pub scty_sts: Option<SecurityStatus3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MntngCSD", skip_serializing_if = "Option::is_none") )]
	pub mntng_csd: Option<SystemPartyIdentification2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstrCSD", skip_serializing_if = "Option::is_none") )]
	pub invstr_csd: Option<SystemPartyIdentification2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IssrCSD", skip_serializing_if = "Option::is_none") )]
	pub issr_csd: Option<SystemPartyIdentification2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechIssrCSD", skip_serializing_if = "Option::is_none") )]
	pub tech_issr_csd: Option<SystemPartyIdentification2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CSD", skip_serializing_if = "Option::is_none") )]
	pub csd: Option<SystemPartyIdentification2Choice>,
}

impl SecuritiesSearchCriteria4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.fin_instrm_id { val.validate()? }
		if let Some(ref val) = self.clssfctn_fin_instrm {
			let pattern = Regex::new("[A-Z]{6,6}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "clssfctn_fin_instrm does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.mtrty_dt { val.validate()? }
		if let Some(ref val) = self.isse_dt { val.validate()? }
		if let Some(ref val) = self.isse_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "isse_ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.ctry_of_isse {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry_of_isse does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.scty_sts { val.validate()? }
		if let Some(ref val) = self.mntng_csd { val.validate()? }
		if let Some(ref val) = self.invstr_csd { val.validate()? }
		if let Some(ref val) = self.issr_csd { val.validate()? }
		if let Some(ref val) = self.tech_issr_csd { val.validate()? }
		if let Some(ref val) = self.csd { val.validate()? }
		Ok(())
	}
}


// SecuritiesSettlementStatus1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum SecuritiesSettlementStatus1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "PEND") )]
	CodePEND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PENF") )]
	CodePENF,
}

impl SecuritiesSettlementStatus1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SecuritiesSettlementSystemIdentification2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesSettlementSystemIdentification2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SysId") )]
	pub sys_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SysNm", skip_serializing_if = "Option::is_none") )]
	pub sys_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtryOfJursdctn", skip_serializing_if = "Option::is_none") )]
	pub ctry_of_jursdctn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CSDLglNm", skip_serializing_if = "Option::is_none") )]
	pub csd_lgl_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LEI", skip_serializing_if = "Option::is_none") )]
	pub lei: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RspnsblPty", skip_serializing_if = "Option::is_none") )]
	pub rspnsbl_pty: Option<Vec<Contact9>>,
}

impl SecuritiesSettlementSystemIdentification2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.sys_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "sys_id is shorter than the minimum length of 1".to_string()));
		}
		if self.sys_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "sys_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.sys_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "sys_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "sys_nm exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.ctry_of_jursdctn {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry_of_jursdctn does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.csd_lgl_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "csd_lgl_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "csd_lgl_nm exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.lei {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "lei does not match the required pattern".to_string()));
			}
		}
		if let Some(ref vec) = self.rspnsbl_pty { for item in vec { item.validate()? } }
		Ok(())
	}
}


// SecuritiesTradeVenueCriteria1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesTradeVenueCriteria1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MIC", skip_serializing_if = "Option::is_none") )]
	pub mic: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AnyMIC", skip_serializing_if = "Option::is_none") )]
	pub any_mic: Option<AnyMIC1Code>,
}

impl SecuritiesTradeVenueCriteria1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.mic {
			for item in vec {
				let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
				if !pattern.is_match(&item) {
					return Err(ValidationError::new(1005, "mic does not match the required pattern".to_string()));
				}
			}
		}
		if let Some(ref val) = self.any_mic { val.validate()? }
		Ok(())
	}
}


// SecuritiesTransaction3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesTransaction3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradDt") )]
	pub trad_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgCpcty") )]
	pub tradg_cpcty: RegulatoryTradingCapacity1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Qty") )]
	pub qty: FinancialInstrumentQuantity25Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DgtlTknQty", skip_serializing_if = "Option::is_none") )]
	pub dgtl_tkn_qty: Option<Vec<DigitalTokenAmount2>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DerivNtnlChng", skip_serializing_if = "Option::is_none") )]
	pub deriv_ntnl_chng: Option<VariationType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pric") )]
	pub pric: SecuritiesTransactionPrice22Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NetAmt", skip_serializing_if = "Option::is_none") )]
	pub net_amt: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradVn") )]
	pub trad_vn: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtryOfBrnch", skip_serializing_if = "Option::is_none") )]
	pub ctry_of_brnch: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UpFrntPmt", skip_serializing_if = "Option::is_none") )]
	pub up_frnt_pmt: Option<AmountAndDirection53>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradPlcMtchgId", skip_serializing_if = "Option::is_none") )]
	pub trad_plc_mtchg_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CmplxTradCmpntId", skip_serializing_if = "Option::is_none") )]
	pub cmplx_trad_cmpnt_id: Option<String>,
}

impl SecuritiesTransaction3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tradg_cpcty.validate()?;
		self.qty.validate()?;
		if let Some(ref vec) = self.dgtl_tkn_qty { for item in vec { item.validate()? } }
		if let Some(ref val) = self.deriv_ntnl_chng { val.validate()? }
		self.pric.validate()?;
		let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
		if !pattern.is_match(&self.trad_vn) {
			return Err(ValidationError::new(1005, "trad_vn does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.ctry_of_brnch {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry_of_brnch does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.up_frnt_pmt { val.validate()? }
		if let Some(ref val) = self.trad_plc_mtchg_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "trad_plc_mtchg_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 52 {
				return Err(ValidationError::new(1002, "trad_plc_mtchg_id exceeds the maximum length of 52".to_string()));
			}
		}
		if let Some(ref val) = self.cmplx_trad_cmpnt_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cmplx_trad_cmpnt_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "cmplx_trad_cmpnt_id exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// SecuritiesTransactionIndicator2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesTransactionIndicator2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "WvrInd", skip_serializing_if = "Option::is_none") )]
	pub wvr_ind: Option<Vec<ReportingWaiverType1Code>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ShrtSellgInd", skip_serializing_if = "Option::is_none") )]
	pub shrt_sellg_ind: Option<Side5Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTCPstTradInd", skip_serializing_if = "Option::is_none") )]
	pub otc_pst_trad_ind: Option<Vec<ReportingWaiverType3Code>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RskRdcgTx", skip_serializing_if = "Option::is_none") )]
	pub rsk_rdcg_tx: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctiesFincgTxInd") )]
	pub scties_fincg_tx_ind: bool,
}

impl SecuritiesTransactionIndicator2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.wvr_ind { for item in vec { item.validate()? } }
		if let Some(ref val) = self.shrt_sellg_ind { val.validate()? }
		if let Some(ref vec) = self.otc_pst_trad_ind { for item in vec { item.validate()? } }
		Ok(())
	}
}


// SecuritiesTransactionPrice1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesTransactionPrice1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pdg") )]
	pub pdg: PriceStatus1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ccy", skip_serializing_if = "Option::is_none") )]
	pub ccy: Option<String>,
}

impl SecuritiesTransactionPrice1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pdg.validate()?;
		if let Some(ref val) = self.ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ccy does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// SecuritiesTransactionPrice13Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesTransactionPrice13Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MntryVal", skip_serializing_if = "Option::is_none") )]
	pub mntry_val: Option<AmountAndDirection106>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pctg", skip_serializing_if = "Option::is_none") )]
	pub pctg: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dcml", skip_serializing_if = "Option::is_none") )]
	pub dcml: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BsisPtSprd", skip_serializing_if = "Option::is_none") )]
	pub bsis_pt_sprd: Option<f64>,
}

impl SecuritiesTransactionPrice13Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mntry_val { val.validate()? }
		Ok(())
	}
}


// SecuritiesTransactionPrice14Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesTransactionPrice14Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rate", skip_serializing_if = "Option::is_none") )]
	pub rate: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dcml", skip_serializing_if = "Option::is_none") )]
	pub dcml: Option<f64>,
}

impl SecuritiesTransactionPrice14Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SecuritiesTransactionPrice17Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesTransactionPrice17Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MntryVal", skip_serializing_if = "Option::is_none") )]
	pub mntry_val: Option<AmountAndDirection106>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Unit", skip_serializing_if = "Option::is_none") )]
	pub unit: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pctg", skip_serializing_if = "Option::is_none") )]
	pub pctg: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Yld", skip_serializing_if = "Option::is_none") )]
	pub yld: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dcml", skip_serializing_if = "Option::is_none") )]
	pub dcml: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PdgPric", skip_serializing_if = "Option::is_none") )]
	pub pdg_pric: Option<PriceStatus1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<SecuritiesTransactionPrice5>,
}

impl SecuritiesTransactionPrice17Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mntry_val { val.validate()? }
		if let Some(ref val) = self.pdg_pric { val.validate()? }
		if let Some(ref val) = self.othr { val.validate()? }
		Ok(())
	}
}


// SecuritiesTransactionPrice18Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesTransactionPrice18Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MntryVal", skip_serializing_if = "Option::is_none") )]
	pub mntry_val: Option<AmountAndDirection107>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pctg", skip_serializing_if = "Option::is_none") )]
	pub pctg: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dcml", skip_serializing_if = "Option::is_none") )]
	pub dcml: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BsisPts", skip_serializing_if = "Option::is_none") )]
	pub bsis_pts: Option<f64>,
}

impl SecuritiesTransactionPrice18Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mntry_val { val.validate()? }
		Ok(())
	}
}


// SecuritiesTransactionPrice19Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesTransactionPrice19Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MntryVal", skip_serializing_if = "Option::is_none") )]
	pub mntry_val: Option<AmountAndDirection107>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Unit", skip_serializing_if = "Option::is_none") )]
	pub unit: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pctg", skip_serializing_if = "Option::is_none") )]
	pub pctg: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Yld", skip_serializing_if = "Option::is_none") )]
	pub yld: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dcml", skip_serializing_if = "Option::is_none") )]
	pub dcml: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PdgPric", skip_serializing_if = "Option::is_none") )]
	pub pdg_pric: Option<PriceStatus1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<SecuritiesTransactionPrice5>,
}

impl SecuritiesTransactionPrice19Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mntry_val { val.validate()? }
		if let Some(ref val) = self.pdg_pric { val.validate()? }
		if let Some(ref val) = self.othr { val.validate()? }
		Ok(())
	}
}


// SecuritiesTransactionPrice20Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesTransactionPrice20Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MntryVal", skip_serializing_if = "Option::is_none") )]
	pub mntry_val: Option<AmountAndDirection106>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pctg", skip_serializing_if = "Option::is_none") )]
	pub pctg: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dcml", skip_serializing_if = "Option::is_none") )]
	pub dcml: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BsisPtSprd", skip_serializing_if = "Option::is_none") )]
	pub bsis_pt_sprd: Option<f64>,
}

impl SecuritiesTransactionPrice20Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mntry_val { val.validate()? }
		Ok(())
	}
}


// SecuritiesTransactionPrice21Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesTransactionPrice21Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MntryVal", skip_serializing_if = "Option::is_none") )]
	pub mntry_val: Option<AmountAndDirection53>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pctg", skip_serializing_if = "Option::is_none") )]
	pub pctg: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Yld", skip_serializing_if = "Option::is_none") )]
	pub yld: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BsisPts", skip_serializing_if = "Option::is_none") )]
	pub bsis_pts: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NmnlVal", skip_serializing_if = "Option::is_none") )]
	pub nmnl_val: Option<ActiveOrHistoricCurrencyAndAmount>,
}

impl SecuritiesTransactionPrice21Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mntry_val { val.validate()? }
		if let Some(ref val) = self.nmnl_val { val.validate()? }
		Ok(())
	}
}


// SecuritiesTransactionPrice22Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesTransactionPrice22Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pric", skip_serializing_if = "Option::is_none") )]
	pub pric: Option<SecuritiesTransactionPrice2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DgtlTknPric", skip_serializing_if = "Option::is_none") )]
	pub dgtl_tkn_pric: Option<SecuritiesTransactionPrice7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NoPric", skip_serializing_if = "Option::is_none") )]
	pub no_pric: Option<SecuritiesTransactionPrice6>,
}

impl SecuritiesTransactionPrice22Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.pric { val.validate()? }
		if let Some(ref val) = self.dgtl_tkn_pric { val.validate()? }
		if let Some(ref val) = self.no_pric { val.validate()? }
		Ok(())
	}
}


// SecuritiesTransactionPrice23Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesTransactionPrice23Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MntryVal", skip_serializing_if = "Option::is_none") )]
	pub mntry_val: Option<AmountAndDirection106>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Unit", skip_serializing_if = "Option::is_none") )]
	pub unit: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pctg", skip_serializing_if = "Option::is_none") )]
	pub pctg: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Yld", skip_serializing_if = "Option::is_none") )]
	pub yld: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dcml", skip_serializing_if = "Option::is_none") )]
	pub dcml: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<SecuritiesTransactionPrice5>,
}

impl SecuritiesTransactionPrice23Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mntry_val { val.validate()? }
		if let Some(ref val) = self.othr { val.validate()? }
		Ok(())
	}
}


// SecuritiesTransactionPrice2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesTransactionPrice2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MntryVal", skip_serializing_if = "Option::is_none") )]
	pub mntry_val: Option<AmountAndDirection61>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pctg", skip_serializing_if = "Option::is_none") )]
	pub pctg: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Yld", skip_serializing_if = "Option::is_none") )]
	pub yld: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BsisPts", skip_serializing_if = "Option::is_none") )]
	pub bsis_pts: Option<f64>,
}

impl SecuritiesTransactionPrice2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mntry_val { val.validate()? }
		Ok(())
	}
}


// SecuritiesTransactionPrice4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesTransactionPrice4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pric", skip_serializing_if = "Option::is_none") )]
	pub pric: Option<SecuritiesTransactionPrice2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NoPric", skip_serializing_if = "Option::is_none") )]
	pub no_pric: Option<SecuritiesTransactionPrice1>,
}

impl SecuritiesTransactionPrice4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.pric { val.validate()? }
		if let Some(ref val) = self.no_pric { val.validate()? }
		Ok(())
	}
}


// SecuritiesTransactionPrice5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesTransactionPrice5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val", skip_serializing_if = "Option::is_none") )]
	pub val: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<String>,
}

impl SecuritiesTransactionPrice5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tp exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// SecuritiesTransactionPrice6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesTransactionPrice6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pdg") )]
	pub pdg: PriceStatus1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ccy", skip_serializing_if = "Option::is_none") )]
	pub ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DgtlTkn", skip_serializing_if = "Option::is_none") )]
	pub dgtl_tkn: Option<Vec<DigitalTokenAmount2>>,
}

impl SecuritiesTransactionPrice6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pdg.validate()?;
		if let Some(ref val) = self.ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref vec) = self.dgtl_tkn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// SecuritiesTransactionPrice7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesTransactionPrice7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MntryVal") )]
	pub mntry_val: AmountAndDirection61,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DgtlTknQty") )]
	pub dgtl_tkn_qty: DigitalTokenAmount2,
}

impl SecuritiesTransactionPrice7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.mntry_val.validate()?;
		self.dgtl_tkn_qty.validate()?;
		Ok(())
	}
}


// SecuritiesTransactionReferences1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesTransactionReferences1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctOwnrTxId", skip_serializing_if = "Option::is_none") )]
	pub acct_ownr_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcrTxId", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktInfrstrctrTxId", skip_serializing_if = "Option::is_none") )]
	pub mkt_infrstrctr_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrcgId", skip_serializing_if = "Option::is_none") )]
	pub prcg_id: Option<String>,
}

impl SecuritiesTransactionReferences1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.acct_ownr_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_ownr_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acct_ownr_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.acct_svcr_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_svcr_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acct_svcr_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.mkt_infrstrctr_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mkt_infrstrctr_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "mkt_infrstrctr_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.prcg_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prcg_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prcg_id exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// SecuritiesTransactionReport2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesTransactionReport2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxId") )]
	pub tx_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExctgPty") )]
	pub exctg_pty: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubmitgPty") )]
	pub submitg_pty: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechAttrbts", skip_serializing_if = "Option::is_none") )]
	pub tech_attrbts: Option<RecordTechnicalData2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl SecuritiesTransactionReport2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.tx_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "tx_id is shorter than the minimum length of 1".to_string()));
		}
		if self.tx_id.chars().count() > 52 {
			return Err(ValidationError::new(1002, "tx_id exceeds the maximum length of 52".to_string()));
		}
		let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
		if !pattern.is_match(&self.exctg_pty) {
			return Err(ValidationError::new(1005, "exctg_pty does not match the required pattern".to_string()));
		}
		let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
		if !pattern.is_match(&self.submitg_pty) {
			return Err(ValidationError::new(1005, "submitg_pty does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.tech_attrbts { val.validate()? }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// SecuritiesTransactionReport7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesTransactionReport7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxId") )]
	pub tx_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExctgPty") )]
	pub exctg_pty: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstmtPtyInd") )]
	pub invstmt_pty_ind: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubmitgPty") )]
	pub submitg_pty: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Buyr") )]
	pub buyr: PartyIdentification79,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sellr") )]
	pub sellr: PartyIdentification79,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrdrTrnsmssn") )]
	pub ordr_trnsmssn: SecuritiesTransactionTransmission2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tx") )]
	pub tx: SecuritiesTransaction3,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrm") )]
	pub fin_instrm: FinancialInstrumentAttributes5Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstmtDcsnPrsn", skip_serializing_if = "Option::is_none") )]
	pub invstmt_dcsn_prsn: Option<InvestmentParty1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExctgPrsn") )]
	pub exctg_prsn: ExecutingParty1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlAttrbts") )]
	pub addtl_attrbts: SecuritiesTransactionIndicator2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechAttrbts", skip_serializing_if = "Option::is_none") )]
	pub tech_attrbts: Option<RecordTechnicalData5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl SecuritiesTransactionReport7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.tx_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "tx_id is shorter than the minimum length of 1".to_string()));
		}
		if self.tx_id.chars().count() > 52 {
			return Err(ValidationError::new(1002, "tx_id exceeds the maximum length of 52".to_string()));
		}
		let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
		if !pattern.is_match(&self.exctg_pty) {
			return Err(ValidationError::new(1005, "exctg_pty does not match the required pattern".to_string()));
		}
		let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
		if !pattern.is_match(&self.submitg_pty) {
			return Err(ValidationError::new(1005, "submitg_pty does not match the required pattern".to_string()));
		}
		self.buyr.validate()?;
		self.sellr.validate()?;
		self.ordr_trnsmssn.validate()?;
		self.tx.validate()?;
		self.fin_instrm.validate()?;
		if let Some(ref val) = self.invstmt_dcsn_prsn { val.validate()? }
		self.exctg_prsn.validate()?;
		self.addtl_attrbts.validate()?;
		if let Some(ref val) = self.tech_attrbts { val.validate()? }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// SecuritiesTransactionTransmission2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesTransactionTransmission2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrnsmssnInd") )]
	pub trnsmssn_ind: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrnsmttgBuyr", skip_serializing_if = "Option::is_none") )]
	pub trnsmttg_buyr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrnsmttgSellr", skip_serializing_if = "Option::is_none") )]
	pub trnsmttg_sellr: Option<String>,
}

impl SecuritiesTransactionTransmission2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.trnsmttg_buyr {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "trnsmttg_buyr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.trnsmttg_sellr {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "trnsmttg_sellr does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// SecuritiesTransactionType11Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum SecuritiesTransactionType11Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "NSYN") )]
	CodeNSYN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SYND") )]
	CodeSYND,
}

impl SecuritiesTransactionType11Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SecuritiesTransactionType15Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum SecuritiesTransactionType15Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "BUYI") )]
	CodeBUYI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SELL") )]
	CodeSELL,
}

impl SecuritiesTransactionType15Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SecuritiesTransactionType31Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesTransactionType31Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<SecuritiesTransactionType11Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl SecuritiesTransactionType31Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// SecuritiesUpdateReason1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecuritiesUpdateReason1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl SecuritiesUpdateReason1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// Security48 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Security48 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<CompareISINIdentifier4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClssfctnTp", skip_serializing_if = "Option::is_none") )]
	pub clssfctn_tp: Option<CompareCFIIdentifier3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Qty", skip_serializing_if = "Option::is_none") )]
	pub qty: Option<CompareDecimalNumber3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NmnlVal", skip_serializing_if = "Option::is_none") )]
	pub nmnl_val: Option<CompareAmountAndDirection2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Qlty", skip_serializing_if = "Option::is_none") )]
	pub qlty: Option<CompareCollateralQualityType3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mtrty", skip_serializing_if = "Option::is_none") )]
	pub mtrty: Option<CompareDate3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IssrId", skip_serializing_if = "Option::is_none") )]
	pub issr_id: Option<CompareOrganisationIdentification6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IssrCtry", skip_serializing_if = "Option::is_none") )]
	pub issr_ctry: Option<CompareCountryCode3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<Vec<CompareSecuritiesLendingType3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnitPric", skip_serializing_if = "Option::is_none") )]
	pub unit_pric: Option<CompareUnitPrice6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExclsvArrgmnt", skip_serializing_if = "Option::is_none") )]
	pub exclsv_arrgmnt: Option<CompareTrueFalseIndicator3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktVal", skip_serializing_if = "Option::is_none") )]
	pub mkt_val: Option<CompareAmountAndDirection2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AvlblForCollReuse", skip_serializing_if = "Option::is_none") )]
	pub avlbl_for_coll_reuse: Option<CompareTrueFalseIndicator3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HrcutOrMrgn", skip_serializing_if = "Option::is_none") )]
	pub hrcut_or_mrgn: Option<ComparePercentageRate3>,
}

impl Security48 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.id { val.validate()? }
		if let Some(ref val) = self.clssfctn_tp { val.validate()? }
		if let Some(ref val) = self.qty { val.validate()? }
		if let Some(ref val) = self.nmnl_val { val.validate()? }
		if let Some(ref val) = self.qlty { val.validate()? }
		if let Some(ref val) = self.mtrty { val.validate()? }
		if let Some(ref val) = self.issr_id { val.validate()? }
		if let Some(ref val) = self.issr_ctry { val.validate()? }
		if let Some(ref vec) = self.tp { for item in vec { item.validate()? } }
		if let Some(ref val) = self.unit_pric { val.validate()? }
		if let Some(ref val) = self.exclsv_arrgmnt { val.validate()? }
		if let Some(ref val) = self.mkt_val { val.validate()? }
		if let Some(ref val) = self.avlbl_for_coll_reuse { val.validate()? }
		if let Some(ref val) = self.hrcut_or_mrgn { val.validate()? }
		Ok(())
	}
}


// Security49 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Security49 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClssfctnTp", skip_serializing_if = "Option::is_none") )]
	pub clssfctn_tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QtyOrNmnlVal", skip_serializing_if = "Option::is_none") )]
	pub qty_or_nmnl_val: Option<QuantityNominalValue2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnitPric", skip_serializing_if = "Option::is_none") )]
	pub unit_pric: Option<SecuritiesTransactionPrice19Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktVal", skip_serializing_if = "Option::is_none") )]
	pub mkt_val: Option<AmountAndDirection53>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Qlty", skip_serializing_if = "Option::is_none") )]
	pub qlty: Option<CollateralQualityType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mtrty", skip_serializing_if = "Option::is_none") )]
	pub mtrty: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issr", skip_serializing_if = "Option::is_none") )]
	pub issr: Option<SecurityIssuer4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<Vec<SecuritiesLendingType3Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExclsvArrgmnt", skip_serializing_if = "Option::is_none") )]
	pub exclsv_arrgmnt: Option<bool>,
}

impl Security49 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.id {
			let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "id does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.clssfctn_tp {
			let pattern = Regex::new("[A-Z]{6,6}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "clssfctn_tp does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.qty_or_nmnl_val { val.validate()? }
		if let Some(ref val) = self.unit_pric { val.validate()? }
		if let Some(ref val) = self.mkt_val { val.validate()? }
		if let Some(ref val) = self.qlty { val.validate()? }
		if let Some(ref val) = self.issr { val.validate()? }
		if let Some(ref vec) = self.tp { for item in vec { item.validate()? } }
		Ok(())
	}
}


// Security51 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Security51 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClssfctnTp", skip_serializing_if = "Option::is_none") )]
	pub clssfctn_tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QtyOrNmnlVal", skip_serializing_if = "Option::is_none") )]
	pub qty_or_nmnl_val: Option<QuantityNominalValue2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnitPric", skip_serializing_if = "Option::is_none") )]
	pub unit_pric: Option<SecuritiesTransactionPrice19Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktVal", skip_serializing_if = "Option::is_none") )]
	pub mkt_val: Option<AmountAndDirection53>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Qlty", skip_serializing_if = "Option::is_none") )]
	pub qlty: Option<CollateralQualityType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mtrty", skip_serializing_if = "Option::is_none") )]
	pub mtrty: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issr", skip_serializing_if = "Option::is_none") )]
	pub issr: Option<SecurityIssuer4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<Vec<SecuritiesLendingType3Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExclsvArrgmnt", skip_serializing_if = "Option::is_none") )]
	pub exclsv_arrgmnt: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AvlblForCollReuse", skip_serializing_if = "Option::is_none") )]
	pub avlbl_for_coll_reuse: Option<bool>,
}

impl Security51 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.id {
			let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "id does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.clssfctn_tp {
			let pattern = Regex::new("[A-Z]{6,6}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "clssfctn_tp does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.qty_or_nmnl_val { val.validate()? }
		if let Some(ref val) = self.unit_pric { val.validate()? }
		if let Some(ref val) = self.mkt_val { val.validate()? }
		if let Some(ref val) = self.qlty { val.validate()? }
		if let Some(ref val) = self.issr { val.validate()? }
		if let Some(ref vec) = self.tp { for item in vec { item.validate()? } }
		Ok(())
	}
}


// Security52 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Security52 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClssfctnTp", skip_serializing_if = "Option::is_none") )]
	pub clssfctn_tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QtyOrNmnlVal", skip_serializing_if = "Option::is_none") )]
	pub qty_or_nmnl_val: Option<QuantityNominalValue2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnitPric", skip_serializing_if = "Option::is_none") )]
	pub unit_pric: Option<SecuritiesTransactionPrice19Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktVal", skip_serializing_if = "Option::is_none") )]
	pub mkt_val: Option<AmountAndDirection53>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Qlty", skip_serializing_if = "Option::is_none") )]
	pub qlty: Option<CollateralQualityType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mtrty", skip_serializing_if = "Option::is_none") )]
	pub mtrty: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issr", skip_serializing_if = "Option::is_none") )]
	pub issr: Option<SecurityIssuer4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<Vec<SecuritiesLendingType3Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExclsvArrgmnt", skip_serializing_if = "Option::is_none") )]
	pub exclsv_arrgmnt: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HrcutOrMrgn", skip_serializing_if = "Option::is_none") )]
	pub hrcut_or_mrgn: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AvlblForCollReuse", skip_serializing_if = "Option::is_none") )]
	pub avlbl_for_coll_reuse: Option<bool>,
}

impl Security52 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.id {
			let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "id does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.clssfctn_tp {
			let pattern = Regex::new("[A-Z]{6,6}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "clssfctn_tp does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.qty_or_nmnl_val { val.validate()? }
		if let Some(ref val) = self.unit_pric { val.validate()? }
		if let Some(ref val) = self.mkt_val { val.validate()? }
		if let Some(ref val) = self.qlty { val.validate()? }
		if let Some(ref val) = self.issr { val.validate()? }
		if let Some(ref vec) = self.tp { for item in vec { item.validate()? } }
		Ok(())
	}
}


// Security55 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Security55 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClssfctnTp", skip_serializing_if = "Option::is_none") )]
	pub clssfctn_tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QtyOrNmnlVal", skip_serializing_if = "Option::is_none") )]
	pub qty_or_nmnl_val: Option<QuantityNominalValue2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnitPric", skip_serializing_if = "Option::is_none") )]
	pub unit_pric: Option<SecuritiesTransactionPrice19Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktVal", skip_serializing_if = "Option::is_none") )]
	pub mkt_val: Option<AmountAndDirection53>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Qlty", skip_serializing_if = "Option::is_none") )]
	pub qlty: Option<CollateralQualityType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mtrty", skip_serializing_if = "Option::is_none") )]
	pub mtrty: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issr", skip_serializing_if = "Option::is_none") )]
	pub issr: Option<SecurityIssuer4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<Vec<SecuritiesLendingType3Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExclsvArrgmnt", skip_serializing_if = "Option::is_none") )]
	pub exclsv_arrgmnt: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AvlblForCollReuse", skip_serializing_if = "Option::is_none") )]
	pub avlbl_for_coll_reuse: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HrcutOrMrgn", skip_serializing_if = "Option::is_none") )]
	pub hrcut_or_mrgn: Option<f64>,
}

impl Security55 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.id {
			let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "id does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.clssfctn_tp {
			let pattern = Regex::new("[A-Z]{6,6}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "clssfctn_tp does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.qty_or_nmnl_val { val.validate()? }
		if let Some(ref val) = self.unit_pric { val.validate()? }
		if let Some(ref val) = self.mkt_val { val.validate()? }
		if let Some(ref val) = self.qlty { val.validate()? }
		if let Some(ref val) = self.issr { val.validate()? }
		if let Some(ref vec) = self.tp { for item in vec { item.validate()? } }
		Ok(())
	}
}


// SecurityAttributes10 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecurityAttributes10 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmId") )]
	pub fin_instrm_id: SecurityIdentification39,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmTp", skip_serializing_if = "Option::is_none") )]
	pub fin_instrm_tp: Option<Vec<FinancialInstrument97>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmAttrbts", skip_serializing_if = "Option::is_none") )]
	pub fin_instrm_attrbts: Option<Vec<CommonFinancialInstrumentAttributes10>>,
}

impl SecurityAttributes10 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.fin_instrm_id.validate()?;
		if let Some(ref vec) = self.fin_instrm_tp { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.fin_instrm_attrbts { for item in vec { item.validate()? } }
		Ok(())
	}
}


// SecurityAttributes11 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecurityAttributes11 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmId", skip_serializing_if = "Option::is_none") )]
	pub fin_instrm_id: Option<Vec<SecurityIdentification39>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmTp", skip_serializing_if = "Option::is_none") )]
	pub fin_instrm_tp: Option<FinancialInstrument97>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmAttrbts", skip_serializing_if = "Option::is_none") )]
	pub fin_instrm_attrbts: Option<Vec<CommonFinancialInstrumentAttributes11>>,
}

impl SecurityAttributes11 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.fin_instrm_id { for item in vec { item.validate()? } }
		if let Some(ref val) = self.fin_instrm_tp { val.validate()? }
		if let Some(ref vec) = self.fin_instrm_attrbts { for item in vec { item.validate()? } }
		Ok(())
	}
}


// SecurityAttributes12 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecurityAttributes12 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmTp", skip_serializing_if = "Option::is_none") )]
	pub fin_instrm_tp: Option<Vec<FinancialInstrument97>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmAttrbts", skip_serializing_if = "Option::is_none") )]
	pub fin_instrm_attrbts: Option<Vec<CommonFinancialInstrumentAttributes12>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl SecurityAttributes12 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.fin_instrm_tp { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.fin_instrm_attrbts { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// SecurityCSDLink7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecurityCSDLink7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldFr") )]
	pub vld_fr: DateAndDateTime2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldTo", skip_serializing_if = "Option::is_none") )]
	pub vld_to: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctyMntnc", skip_serializing_if = "Option::is_none") )]
	pub scty_mntnc: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IssrCSD", skip_serializing_if = "Option::is_none") )]
	pub issr_csd: Option<SystemPartyIdentification2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstrCSD", skip_serializing_if = "Option::is_none") )]
	pub invstr_csd: Option<SystemPartyIdentification2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechIssrCSD", skip_serializing_if = "Option::is_none") )]
	pub tech_issr_csd: Option<SystemPartyIdentification2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IssncAcct", skip_serializing_if = "Option::is_none") )]
	pub issnc_acct: Option<Vec<IssuanceAccount2>>,
}

impl SecurityCSDLink7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.vld_fr.validate()?;
		if let Some(ref val) = self.vld_to { val.validate()? }
		if let Some(ref val) = self.issr_csd { val.validate()? }
		if let Some(ref val) = self.invstr_csd { val.validate()? }
		if let Some(ref val) = self.tech_issr_csd { val.validate()? }
		if let Some(ref vec) = self.issnc_acct { for item in vec { item.validate()? } }
		Ok(())
	}
}


// SecurityClassificationType2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecurityClassificationType2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CFI", skip_serializing_if = "Option::is_none") )]
	pub cfi: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AltrnClssfctn", skip_serializing_if = "Option::is_none") )]
	pub altrn_clssfctn: Option<GenericIdentification3>,
}

impl SecurityClassificationType2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cfi {
			let pattern = Regex::new("[A-Z]{6,6}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "cfi does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.altrn_clssfctn { val.validate()? }
		Ok(())
	}
}


// SecurityCommodity7Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecurityCommodity7Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Scty", skip_serializing_if = "Option::is_none") )]
	pub scty: Option<Vec<Security48>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cmmdty", skip_serializing_if = "Option::is_none") )]
	pub cmmdty: Option<Vec<Commodity42>>,
}

impl SecurityCommodity7Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.scty { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.cmmdty { for item in vec { item.validate()? } }
		Ok(())
	}
}


// SecurityCommodity9 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecurityCommodity9 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Scty", skip_serializing_if = "Option::is_none") )]
	pub scty: Option<Vec<Security51>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cmmdty", skip_serializing_if = "Option::is_none") )]
	pub cmmdty: Option<Vec<Commodity43>>,
}

impl SecurityCommodity9 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.scty { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.cmmdty { for item in vec { item.validate()? } }
		Ok(())
	}
}


// SecurityCommodityCash4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecurityCommodityCash4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Scty", skip_serializing_if = "Option::is_none") )]
	pub scty: Option<Vec<Security48>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cmmdty", skip_serializing_if = "Option::is_none") )]
	pub cmmdty: Option<Vec<Commodity42>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Csh", skip_serializing_if = "Option::is_none") )]
	pub csh: Option<Vec<CashCompare3>>,
}

impl SecurityCommodityCash4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.scty { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.cmmdty { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.csh { for item in vec { item.validate()? } }
		Ok(())
	}
}


// SecurityIdentification19 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecurityIdentification19 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISIN", skip_serializing_if = "Option::is_none") )]
	pub isin: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrId", skip_serializing_if = "Option::is_none") )]
	pub othr_id: Option<Vec<OtherIdentification1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Desc", skip_serializing_if = "Option::is_none") )]
	pub desc: Option<String>,
}

impl SecurityIdentification19 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.isin {
			let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "isin does not match the required pattern".to_string()));
			}
		}
		if let Some(ref vec) = self.othr_id { for item in vec { item.validate()? } }
		if let Some(ref val) = self.desc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "desc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "desc exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// SecurityIdentification20Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecurityIdentification20Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISIN", skip_serializing_if = "Option::is_none") )]
	pub isin: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
}

impl SecurityIdentification20Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.isin {
			let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "isin does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 25 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 25".to_string()));
			}
		}
		Ok(())
	}
}


// SecurityIdentification25Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecurityIdentification25Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISIN", skip_serializing_if = "Option::is_none") )]
	pub isin: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SEDOL", skip_serializing_if = "Option::is_none") )]
	pub sedol: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CUSIP", skip_serializing_if = "Option::is_none") )]
	pub cusip: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RIC", skip_serializing_if = "Option::is_none") )]
	pub ric: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TckrSymb", skip_serializing_if = "Option::is_none") )]
	pub tckr_symb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Blmbrg", skip_serializing_if = "Option::is_none") )]
	pub blmbrg: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CTA", skip_serializing_if = "Option::is_none") )]
	pub cta: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QUICK", skip_serializing_if = "Option::is_none") )]
	pub quick: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Wrtppr", skip_serializing_if = "Option::is_none") )]
	pub wrtppr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dtch", skip_serializing_if = "Option::is_none") )]
	pub dtch: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Vlrn", skip_serializing_if = "Option::is_none") )]
	pub vlrn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SCVM", skip_serializing_if = "Option::is_none") )]
	pub scvm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Belgn", skip_serializing_if = "Option::is_none") )]
	pub belgn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cmon", skip_serializing_if = "Option::is_none") )]
	pub cmon: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrPrtryId", skip_serializing_if = "Option::is_none") )]
	pub othr_prtry_id: Option<AlternateSecurityIdentification7>,
}

impl SecurityIdentification25Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.isin {
			let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "isin does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.ric {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ric is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "ric exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.tckr_symb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tckr_symb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tckr_symb exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.blmbrg {
			let pattern = Regex::new("(BBG)[BCDFGHJKLMNPQRSTVWXYZ\\d]{8}\\d").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "blmbrg does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.cta {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cta is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "cta exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.cmon {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cmon is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 12 {
				return Err(ValidationError::new(1002, "cmon exceeds the maximum length of 12".to_string()));
			}
		}
		if let Some(ref val) = self.othr_prtry_id { val.validate()? }
		Ok(())
	}
}


// SecurityIdentification26Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecurityIdentification26Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NotAvlbl", skip_serializing_if = "Option::is_none") )]
	pub not_avlbl: Option<NotAvailable1Code>,
}

impl SecurityIdentification26Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.id {
			let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "id does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.not_avlbl { val.validate()? }
		Ok(())
	}
}


// SecurityIdentification39 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecurityIdentification39 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISIN", skip_serializing_if = "Option::is_none") )]
	pub isin: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrId", skip_serializing_if = "Option::is_none") )]
	pub othr_id: Option<Vec<OtherIdentification1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Desc", skip_serializing_if = "Option::is_none") )]
	pub desc: Option<String>,
}

impl SecurityIdentification39 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.isin {
			let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "isin does not match the required pattern".to_string()));
			}
		}
		if let Some(ref vec) = self.othr_id { for item in vec { item.validate()? } }
		if let Some(ref val) = self.desc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "desc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "desc exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// SecurityIdentification3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecurityIdentification3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISIN", skip_serializing_if = "Option::is_none") )]
	pub isin: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SEDOL", skip_serializing_if = "Option::is_none") )]
	pub sedol: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CUSIP", skip_serializing_if = "Option::is_none") )]
	pub cusip: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RIC", skip_serializing_if = "Option::is_none") )]
	pub ric: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TckrSymb", skip_serializing_if = "Option::is_none") )]
	pub tckr_symb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Blmbrg", skip_serializing_if = "Option::is_none") )]
	pub blmbrg: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CTA", skip_serializing_if = "Option::is_none") )]
	pub cta: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QUICK", skip_serializing_if = "Option::is_none") )]
	pub quick: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Wrtppr", skip_serializing_if = "Option::is_none") )]
	pub wrtppr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dtch", skip_serializing_if = "Option::is_none") )]
	pub dtch: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Vlrn", skip_serializing_if = "Option::is_none") )]
	pub vlrn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SCVM", skip_serializing_if = "Option::is_none") )]
	pub scvm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Belgn", skip_serializing_if = "Option::is_none") )]
	pub belgn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cmon", skip_serializing_if = "Option::is_none") )]
	pub cmon: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrPrtryId", skip_serializing_if = "Option::is_none") )]
	pub othr_prtry_id: Option<AlternateSecurityIdentification1>,
}

impl SecurityIdentification3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.isin {
			let pattern = Regex::new("[A-Z0-9]{12,12}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "isin does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.ric {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ric is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "ric exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.tckr_symb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tckr_symb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tckr_symb exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.blmbrg {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "blmbrg is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "blmbrg exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.cta {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cta is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "cta exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.cmon {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cmon is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 12 {
				return Err(ValidationError::new(1002, "cmon exceeds the maximum length of 12".to_string()));
			}
		}
		if let Some(ref val) = self.othr_prtry_id { val.validate()? }
		Ok(())
	}
}


// SecurityIdentification40 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecurityIdentification40 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrId", skip_serializing_if = "Option::is_none") )]
	pub othr_id: Option<Vec<OtherIdentification1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Desc", skip_serializing_if = "Option::is_none") )]
	pub desc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISIN", skip_serializing_if = "Option::is_none") )]
	pub isin: Option<String>,
}

impl SecurityIdentification40 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.othr_id { for item in vec { item.validate()? } }
		if let Some(ref val) = self.desc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "desc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "desc exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.isin {
			let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "isin does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// SecurityIdentification41Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecurityIdentification41Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISIN", skip_serializing_if = "Option::is_none") )]
	pub isin: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AltrntvInstrmId", skip_serializing_if = "Option::is_none") )]
	pub altrntv_instrm_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnqPdctIdr", skip_serializing_if = "Option::is_none") )]
	pub unq_pdct_idr: Option<UniqueProductIdentifier2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Bskt", skip_serializing_if = "Option::is_none") )]
	pub bskt: Option<CustomBasket4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Indx", skip_serializing_if = "Option::is_none") )]
	pub indx: Option<IndexIdentification1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<GenericIdentification184>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IdNotAvlbl", skip_serializing_if = "Option::is_none") )]
	pub id_not_avlbl: Option<UnderlyingIdentification1Code>,
}

impl SecurityIdentification41Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.isin {
			let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "isin does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.altrntv_instrm_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "altrntv_instrm_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 52 {
				return Err(ValidationError::new(1002, "altrntv_instrm_id exceeds the maximum length of 52".to_string()));
			}
		}
		if let Some(ref val) = self.unq_pdct_idr { val.validate()? }
		if let Some(ref val) = self.bskt { val.validate()? }
		if let Some(ref val) = self.indx { val.validate()? }
		if let Some(ref val) = self.othr { val.validate()? }
		if let Some(ref val) = self.id_not_avlbl { val.validate()? }
		Ok(())
	}
}


// SecurityIdentification46 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecurityIdentification46 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISIN", skip_serializing_if = "Option::is_none") )]
	pub isin: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnqPdctIdr", skip_serializing_if = "Option::is_none") )]
	pub unq_pdct_idr: Option<UniqueProductIdentifier2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AltrntvInstrmId", skip_serializing_if = "Option::is_none") )]
	pub altrntv_instrm_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PdctDesc", skip_serializing_if = "Option::is_none") )]
	pub pdct_desc: Option<String>,
}

impl SecurityIdentification46 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.isin {
			let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "isin does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.unq_pdct_idr { val.validate()? }
		if let Some(ref val) = self.altrntv_instrm_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "altrntv_instrm_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 105 {
				return Err(ValidationError::new(1002, "altrntv_instrm_id exceeds the maximum length of 105".to_string()));
			}
		}
		if let Some(ref val) = self.pdct_desc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pdct_desc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 1000 {
				return Err(ValidationError::new(1002, "pdct_desc exceeds the maximum length of 1000".to_string()));
			}
		}
		Ok(())
	}
}


// SecurityIdentification47 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecurityIdentification47 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: SecurityIdentification40,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm") )]
	pub nm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ShrtNm", skip_serializing_if = "Option::is_none") )]
	pub shrt_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClssTp", skip_serializing_if = "Option::is_none") )]
	pub clss_tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UmbrllNm", skip_serializing_if = "Option::is_none") )]
	pub umbrll_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NewUmbrll", skip_serializing_if = "Option::is_none") )]
	pub new_umbrll: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClssfctnTp", skip_serializing_if = "Option::is_none") )]
	pub clssfctn_tp: Option<SecurityClassificationType2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BaseCcy", skip_serializing_if = "Option::is_none") )]
	pub base_ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtryOfDmcl", skip_serializing_if = "Option::is_none") )]
	pub ctry_of_dmcl: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegdDstrbtnCtry", skip_serializing_if = "Option::is_none") )]
	pub regd_dstrbtn_ctry: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PdctTp", skip_serializing_if = "Option::is_none") )]
	pub pdct_tp: Option<ProductStructure1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Issr", skip_serializing_if = "Option::is_none") )]
	pub issr: Option<ContactAttributes5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IssrPdctGovncPrc", skip_serializing_if = "Option::is_none") )]
	pub issr_pdct_govnc_prc: Option<GovernanceProcess1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PdctCtgy", skip_serializing_if = "Option::is_none") )]
	pub pdct_ctgy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PdctCtgyDE", skip_serializing_if = "Option::is_none") )]
	pub pdct_ctgy_de: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtnlOrUnitBased", skip_serializing_if = "Option::is_none") )]
	pub ntnl_or_unit_based: Option<NotionalOrUnitBased1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QtnTp", skip_serializing_if = "Option::is_none") )]
	pub qtn_tp: Option<QuotationType1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LvrgdOrCntngntLblty", skip_serializing_if = "Option::is_none") )]
	pub lvrgd_or_cntngnt_lblty: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NoRtrcssnInd", skip_serializing_if = "Option::is_none") )]
	pub no_rtrcssn_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExPstCostClctnBsis", skip_serializing_if = "Option::is_none") )]
	pub ex_pst_cost_clctn_bsis: Option<ExPostCostCalculationBasis1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<Vec<AdditionalInformation15>>,
}

impl SecurityIdentification47 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.id.validate()?;
		if self.nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
		}
		if self.nm.chars().count() > 350 {
			return Err(ValidationError::new(1002, "nm exceeds the maximum length of 350".to_string()));
		}
		if let Some(ref val) = self.shrt_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "shrt_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "shrt_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.clss_tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "clss_tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "clss_tp exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.umbrll_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "umbrll_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "umbrll_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.clssfctn_tp { val.validate()? }
		if let Some(ref val) = self.base_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "base_ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.ctry_of_dmcl {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry_of_dmcl does not match the required pattern".to_string()));
			}
		}
		if let Some(ref vec) = self.regd_dstrbtn_ctry {
			for item in vec {
				let pattern = Regex::new("[A-Z]{2,2}").unwrap();
				if !pattern.is_match(&item) {
					return Err(ValidationError::new(1005, "regd_dstrbtn_ctry does not match the required pattern".to_string()));
				}
			}
		}
		if let Some(ref val) = self.pdct_tp { val.validate()? }
		if let Some(ref val) = self.issr { val.validate()? }
		if let Some(ref val) = self.issr_pdct_govnc_prc { val.validate()? }
		if let Some(ref val) = self.pdct_ctgy {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pdct_ctgy is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "pdct_ctgy exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.pdct_ctgy_de {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pdct_ctgy_de is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "pdct_ctgy_de exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.ntnl_or_unit_based { val.validate()? }
		if let Some(ref val) = self.qtn_tp { val.validate()? }
		if let Some(ref val) = self.ex_pst_cost_clctn_bsis { val.validate()? }
		if let Some(ref vec) = self.addtl_inf { for item in vec { item.validate()? } }
		Ok(())
	}
}


// SecurityIdentificationAndAmount1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecurityIdentificationAndAmount1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktVal") )]
	pub mkt_val: ActiveCurrencyAnd24Amount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmTp") )]
	pub fin_instrm_tp: ProductType7Code,
}

impl SecurityIdentificationAndAmount1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
		if !pattern.is_match(&self.id) {
			return Err(ValidationError::new(1005, "id does not match the required pattern".to_string()));
		}
		self.mkt_val.validate()?;
		self.fin_instrm_tp.validate()?;
		Ok(())
	}
}


// SecurityIdentificationQuery4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecurityIdentificationQuery4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISIN", skip_serializing_if = "Option::is_none") )]
	pub isin: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AltrntvInstrmId", skip_serializing_if = "Option::is_none") )]
	pub altrntv_instrm_id: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NotAvlbl", skip_serializing_if = "Option::is_none") )]
	pub not_avlbl: Option<NotAvailable1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnqPdctIdr", skip_serializing_if = "Option::is_none") )]
	pub unq_pdct_idr: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Indx", skip_serializing_if = "Option::is_none") )]
	pub indx: Option<Vec<SecurityIdentification20Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Bskt", skip_serializing_if = "Option::is_none") )]
	pub bskt: Option<Vec<BasketQuery1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NotRptd", skip_serializing_if = "Option::is_none") )]
	pub not_rptd: Option<NotReported1Code>,
}

impl SecurityIdentificationQuery4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.isin {
			for item in vec {
				let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
				if !pattern.is_match(&item) {
					return Err(ValidationError::new(1005, "isin does not match the required pattern".to_string()));
				}
			}
		}
		if let Some(ref vec) = self.altrntv_instrm_id {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "altrntv_instrm_id is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 52 {
					return Err(ValidationError::new(1002, "altrntv_instrm_id exceeds the maximum length of 52".to_string()));
				}
			}
		}
		if let Some(ref val) = self.not_avlbl { val.validate()? }
		if let Some(ref vec) = self.unq_pdct_idr {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "unq_pdct_idr is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 52 {
					return Err(ValidationError::new(1002, "unq_pdct_idr exceeds the maximum length of 52".to_string()));
				}
			}
		}
		if let Some(ref vec) = self.indx { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.bskt { for item in vec { item.validate()? } }
		if let Some(ref val) = self.not_rptd { val.validate()? }
		Ok(())
	}
}


// SecurityIdentificationQueryCriteria1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecurityIdentificationQueryCriteria1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISIN", skip_serializing_if = "Option::is_none") )]
	pub isin: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AltrntvInstrmId", skip_serializing_if = "Option::is_none") )]
	pub altrntv_instrm_id: Option<Vec<String>>,
}

impl SecurityIdentificationQueryCriteria1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.isin {
			for item in vec {
				let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
				if !pattern.is_match(&item) {
					return Err(ValidationError::new(1005, "isin does not match the required pattern".to_string()));
				}
			}
		}
		if let Some(ref vec) = self.altrntv_instrm_id {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "altrntv_instrm_id is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 52 {
					return Err(ValidationError::new(1002, "altrntv_instrm_id exceeds the maximum length of 52".to_string()));
				}
			}
		}
		Ok(())
	}
}


// SecurityInstrumentDescription17 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecurityInstrumentDescription17 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FullNm", skip_serializing_if = "Option::is_none") )]
	pub full_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ShrtNm", skip_serializing_if = "Option::is_none") )]
	pub shrt_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClssfctnTp", skip_serializing_if = "Option::is_none") )]
	pub clssfctn_tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtnlCcy", skip_serializing_if = "Option::is_none") )]
	pub ntnl_ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CmmdtyDerivInd", skip_serializing_if = "Option::is_none") )]
	pub cmmdty_deriv_ind: Option<bool>,
}

impl SecurityInstrumentDescription17 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
		if !pattern.is_match(&self.id) {
			return Err(ValidationError::new(1005, "id does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.full_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "full_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "full_nm exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.shrt_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "shrt_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "shrt_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.clssfctn_tp {
			let pattern = Regex::new("[A-Z]{6,6}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "clssfctn_tp does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.ntnl_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ntnl_ccy does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// SecurityInstrumentDescription22 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecurityInstrumentDescription22 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmGnlAttrbts") )]
	pub fin_instrm_gnl_attrbts: SecurityInstrumentDescription23,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DebtInstrmAttrbts", skip_serializing_if = "Option::is_none") )]
	pub debt_instrm_attrbts: Option<DebtInstrument4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DerivInstrmAttrbts") )]
	pub deriv_instrm_attrbts: DerivativeInstrument6,
}

impl SecurityInstrumentDescription22 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.fin_instrm_gnl_attrbts.validate()?;
		if let Some(ref val) = self.debt_instrm_attrbts { val.validate()? }
		self.deriv_instrm_attrbts.validate()?;
		Ok(())
	}
}


// SecurityInstrumentDescription23 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecurityInstrumentDescription23 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrId", skip_serializing_if = "Option::is_none") )]
	pub othr_id: Option<Vec<OtherIdentification1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FullNm") )]
	pub full_nm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClssfctnTp") )]
	pub clssfctn_tp: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtnlCcy", skip_serializing_if = "Option::is_none") )]
	pub ntnl_ccy: Option<String>,
}

impl SecurityInstrumentDescription23 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.id {
			let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "id does not match the required pattern".to_string()));
			}
		}
		if let Some(ref vec) = self.othr_id { for item in vec { item.validate()? } }
		if self.full_nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "full_nm is shorter than the minimum length of 1".to_string()));
		}
		if self.full_nm.chars().count() > 350 {
			return Err(ValidationError::new(1002, "full_nm exceeds the maximum length of 350".to_string()));
		}
		let pattern = Regex::new("[A-Z]{6,6}").unwrap();
		if !pattern.is_match(&self.clssfctn_tp) {
			return Err(ValidationError::new(1005, "clssfctn_tp does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.ntnl_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ntnl_ccy does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// SecurityInstrumentDescription9 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecurityInstrumentDescription9 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FullNm") )]
	pub full_nm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ShrtNm", skip_serializing_if = "Option::is_none") )]
	pub shrt_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClssfctnTp") )]
	pub clssfctn_tp: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtnlCcy") )]
	pub ntnl_ccy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CmmdtyDerivInd") )]
	pub cmmdty_deriv_ind: bool,
}

impl SecurityInstrumentDescription9 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
		if !pattern.is_match(&self.id) {
			return Err(ValidationError::new(1005, "id does not match the required pattern".to_string()));
		}
		if self.full_nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "full_nm is shorter than the minimum length of 1".to_string()));
		}
		if self.full_nm.chars().count() > 350 {
			return Err(ValidationError::new(1002, "full_nm exceeds the maximum length of 350".to_string()));
		}
		if let Some(ref val) = self.shrt_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "shrt_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "shrt_nm exceeds the maximum length of 35".to_string()));
			}
		}
		let pattern = Regex::new("[A-Z]{6,6}").unwrap();
		if !pattern.is_match(&self.clssfctn_tp) {
			return Err(ValidationError::new(1005, "clssfctn_tp does not match the required pattern".to_string()));
		}
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.ntnl_ccy) {
			return Err(ValidationError::new(1005, "ntnl_ccy does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// SecurityIssuer4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecurityIssuer4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<OrganisationIdentification15Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "JursdctnCtry") )]
	pub jursdctn_ctry: String,
}

impl SecurityIssuer4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.id { val.validate()? }
		let pattern = Regex::new("[A-Z]{2,2}").unwrap();
		if !pattern.is_match(&self.jursdctn_ctry) {
			return Err(ValidationError::new(1005, "jursdctn_ctry does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// SecurityOrBusinessError4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecurityOrBusinessError4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctyRpt", skip_serializing_if = "Option::is_none") )]
	pub scty_rpt: Option<Vec<SecurityAttributes11>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizErr", skip_serializing_if = "Option::is_none") )]
	pub biz_err: Option<Vec<BusinessError4>>,
}

impl SecurityOrBusinessError4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.scty_rpt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.biz_err { for item in vec { item.validate()? } }
		Ok(())
	}
}


// SecurityOrOperationalError4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecurityOrOperationalError4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctyRptOrBizErr", skip_serializing_if = "Option::is_none") )]
	pub scty_rpt_or_biz_err: Option<SecurityOrBusinessError4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OprlErr", skip_serializing_if = "Option::is_none") )]
	pub oprl_err: Option<Vec<ErrorHandling5>>,
}

impl SecurityOrOperationalError4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.scty_rpt_or_biz_err { val.validate()? }
		if let Some(ref vec) = self.oprl_err { for item in vec { item.validate()? } }
		Ok(())
	}
}


// SecurityRestriction3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecurityRestriction3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FctvPrd", skip_serializing_if = "Option::is_none") )]
	pub fctv_prd: Option<DateTimePeriod2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RstrctnTp", skip_serializing_if = "Option::is_none") )]
	pub rstrctn_tp: Option<SecurityRestrictionType2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LglRstrctnTp", skip_serializing_if = "Option::is_none") )]
	pub lgl_rstrctn_tp: Option<LegalRestrictions5Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstrRstrctnTp", skip_serializing_if = "Option::is_none") )]
	pub invstr_rstrctn_tp: Option<Vec<InvestorRestrictionType3Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstrTp", skip_serializing_if = "Option::is_none") )]
	pub invstr_tp: Option<Vec<InvestorType3Choice>>,
}

impl SecurityRestriction3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.fctv_prd { val.validate()? }
		if let Some(ref val) = self.rstrctn_tp { val.validate()? }
		if let Some(ref val) = self.lgl_rstrctn_tp { val.validate()? }
		if let Some(ref vec) = self.invstr_rstrctn_tp { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.invstr_tp { for item in vec { item.validate()? } }
		Ok(())
	}
}


// SecurityRestrictionType2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecurityRestrictionType2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RstrctnTp", skip_serializing_if = "Option::is_none") )]
	pub rstrctn_tp: Option<RestrictionType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtryRstrctn", skip_serializing_if = "Option::is_none") )]
	pub prtry_rstrctn: Option<GenericIdentification30>,
}

impl SecurityRestrictionType2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rstrctn_tp { val.validate()? }
		if let Some(ref val) = self.prtry_rstrctn { val.validate()? }
		Ok(())
	}
}


// SecurityReuseData1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecurityReuseData1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISIN") )]
	pub isin: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReuseVal") )]
	pub reuse_val: ReuseValue1Choice,
}

impl SecurityReuseData1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
		if !pattern.is_match(&self.isin) {
			return Err(ValidationError::new(1005, "isin does not match the required pattern".to_string()));
		}
		self.reuse_val.validate()?;
		Ok(())
	}
}


// SecurityStatement3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecurityStatement3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SysDt") )]
	pub sys_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Chng", skip_serializing_if = "Option::is_none") )]
	pub chng: Option<Vec<SecuritiesReferenceDataChange3>>,
}

impl SecurityStatement3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.chng { for item in vec { item.validate()? } }
		Ok(())
	}
}


// SecurityStatus2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum SecurityStatus2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACTV") )]
	CodeACTV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INAC") )]
	CodeINAC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SUSP") )]
	CodeSUSP,
}

impl SecurityStatus2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SecurityStatus3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecurityStatus3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<SecurityStatus2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl SecurityStatus3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// SecurityWithHoldingTax1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SecurityWithHoldingTax1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "WhldgTaxVal") )]
	pub whldg_tax_val: RateAndAmountFormat1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctry") )]
	pub ctry: String,
}

impl SecurityWithHoldingTax1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.whldg_tax_val.validate()?;
		let pattern = Regex::new("[A-Z]{2,2}").unwrap();
		if !pattern.is_match(&self.ctry) {
			return Err(ValidationError::new(1005, "ctry does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// SequenceRange1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SequenceRange1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrSeq") )]
	pub fr_seq: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ToSeq") )]
	pub to_seq: String,
}

impl SequenceRange1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.fr_seq.chars().count() < 1 {
			return Err(ValidationError::new(1001, "fr_seq is shorter than the minimum length of 1".to_string()));
		}
		if self.fr_seq.chars().count() > 35 {
			return Err(ValidationError::new(1002, "fr_seq exceeds the maximum length of 35".to_string()));
		}
		if self.to_seq.chars().count() < 1 {
			return Err(ValidationError::new(1001, "to_seq is shorter than the minimum length of 1".to_string()));
		}
		if self.to_seq.chars().count() > 35 {
			return Err(ValidationError::new(1002, "to_seq exceeds the maximum length of 35".to_string()));
		}
		Ok(())
	}
}


// SequenceRange1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SequenceRange1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrSeq", skip_serializing_if = "Option::is_none") )]
	pub fr_seq: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ToSeq", skip_serializing_if = "Option::is_none") )]
	pub to_seq: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrToSeq", skip_serializing_if = "Option::is_none") )]
	pub fr_to_seq: Option<Vec<SequenceRange1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EQSeq", skip_serializing_if = "Option::is_none") )]
	pub eq_seq: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NEQSeq", skip_serializing_if = "Option::is_none") )]
	pub neq_seq: Option<Vec<String>>,
}

impl SequenceRange1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.fr_seq {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "fr_seq is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "fr_seq exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.to_seq {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "to_seq is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "to_seq exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref vec) = self.fr_to_seq { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.eq_seq {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "eq_seq is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 35 {
					return Err(ValidationError::new(1002, "eq_seq exceeds the maximum length of 35".to_string()));
				}
			}
		}
		if let Some(ref vec) = self.neq_seq {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "neq_seq is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 35 {
					return Err(ValidationError::new(1002, "neq_seq exceeds the maximum length of 35".to_string()));
				}
			}
		}
		Ok(())
	}
}


// SequenceType2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum SequenceType2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "RCUR") )]
	CodeRCUR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OOFF") )]
	CodeOOFF,
}

impl SequenceType2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SequenceType3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum SequenceType3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "FRST") )]
	CodeFRST,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RCUR") )]
	CodeRCUR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FNAL") )]
	CodeFNAL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OOFF") )]
	CodeOOFF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RPRE") )]
	CodeRPRE,
}

impl SequenceType3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ServiceAdjustmentType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ServiceAdjustmentType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "COMP") )]
	CodeCOMP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NCMP") )]
	CodeNCMP,
}

impl ServiceAdjustmentType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ServiceLevel8Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ServiceLevel8Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl ServiceLevel8Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// ServicePaymentMethod1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ServicePaymentMethod1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "BCMP") )]
	CodeBCMP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FLAT") )]
	CodeFLAT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PVCH") )]
	CodePVCH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INVS") )]
	CodeINVS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WVED") )]
	CodeWVED,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FREE") )]
	CodeFREE,
}

impl ServicePaymentMethod1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ServiceRequestStatus1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ServiceRequestStatus1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACPT") )]
	CodeACPT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RJCT") )]
	CodeRJCT,
}

impl ServiceRequestStatus1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ServiceStatus1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ServiceStatus1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<ServiceRequestStatus1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl ServiceStatus1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// ServiceTaxDesignation1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ServiceTaxDesignation1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd") )]
	pub cd: ServiceTaxDesignation1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rgn", skip_serializing_if = "Option::is_none") )]
	pub rgn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxRsn", skip_serializing_if = "Option::is_none") )]
	pub tax_rsn: Option<Vec<TaxReason1>>,
}

impl ServiceTaxDesignation1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.cd.validate()?;
		if let Some(ref val) = self.rgn {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rgn is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "rgn exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref vec) = self.tax_rsn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// ServiceTaxDesignation1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ServiceTaxDesignation1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "XMPT") )]
	CodeXMPT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ZERO") )]
	CodeZERO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TAXE") )]
	CodeTAXE,
}

impl ServiceTaxDesignation1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SettleStyle1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum SettleStyle1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "SETC") )]
	CodeSETC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SETO") )]
	CodeSETO,
}

impl SettleStyle1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SettleStyle2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettleStyle2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<Vec<SettleStyle1Code>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl SettleStyle2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.cd { for item in vec { item.validate()? } }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// SettlementAccount1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementAccount1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: GenericIdentification165,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndOfDayInitlMrgnClld") )]
	pub end_of_day_initl_mrgn_clld: AmountAndDirection102,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndOfDayVartnMrgnClld") )]
	pub end_of_day_vartn_mrgn_clld: AmountAndDirection102,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndOfDayDfltFndClld") )]
	pub end_of_day_dflt_fnd_clld: AmountAndDirection102,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndOfDaySttlmClld") )]
	pub end_of_day_sttlm_clld: AmountAndDirection102,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndOfDayOthrClld") )]
	pub end_of_day_othr_clld: AmountAndDirection102,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndOfDayLqdtyClld") )]
	pub end_of_day_lqdty_clld: AmountAndDirection102,
}

impl SettlementAccount1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.id.validate()?;
		self.end_of_day_initl_mrgn_clld.validate()?;
		self.end_of_day_vartn_mrgn_clld.validate()?;
		self.end_of_day_dflt_fnd_clld.validate()?;
		self.end_of_day_sttlm_clld.validate()?;
		self.end_of_day_othr_clld.validate()?;
		self.end_of_day_lqdty_clld.validate()?;
		Ok(())
	}
}


// SettlementAgent2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementAgent2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Acct") )]
	pub acct: Vec<PaymentAccount4>,
}

impl SettlementAgent2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
		if !pattern.is_match(&self.id) {
			return Err(ValidationError::new(1005, "id does not match the required pattern".to_string()));
		}
		for item in &self.acct { item.validate()? }
		Ok(())
	}
}


// SettlementDailyFailureReason1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementDailyFailureReason1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DataSetActn", skip_serializing_if = "Option::is_none") )]
	pub data_set_actn: Option<ReportPeriodActivity1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Data", skip_serializing_if = "Option::is_none") )]
	pub data: Option<SettlementDailyFailureReason3>,
}

impl SettlementDailyFailureReason1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.data_set_actn { val.validate()? }
		if let Some(ref val) = self.data { val.validate()? }
		Ok(())
	}
}


// SettlementDailyFailureReason3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementDailyFailureReason3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FaildScties") )]
	pub faild_scties: SettlementTotalData1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FaildCsh") )]
	pub faild_csh: SettlementTotalData1Choice,
}

impl SettlementDailyFailureReason3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.faild_scties.validate()?;
		self.faild_csh.validate()?;
		Ok(())
	}
}


// SettlementDataRate1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementDataRate1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfInstrs", skip_serializing_if = "Option::is_none") )]
	pub nb_of_instrs: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValOfInstrs", skip_serializing_if = "Option::is_none") )]
	pub val_of_instrs: Option<f64>,
}

impl SettlementDataRate1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SettlementDataRate2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementDataRate2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Vol") )]
	pub vol: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val") )]
	pub val: f64,
}

impl SettlementDataRate2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SettlementDataVolume2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementDataVolume2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Vol") )]
	pub vol: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val") )]
	pub val: f64,
}

impl SettlementDataVolume2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SettlementDate6Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum SettlementDate6Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "TFIV") )]
	CodeTFIV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TFOR") )]
	CodeTFOR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TONE") )]
	CodeTONE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TTRE") )]
	CodeTTRE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TTWO") )]
	CodeTTWO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SAMD") )]
	CodeSAMD,
}

impl SettlementDate6Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SettlementDateTimeIndication1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementDateTimeIndication1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtDtTm", skip_serializing_if = "Option::is_none") )]
	pub dbt_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDtTm", skip_serializing_if = "Option::is_none") )]
	pub cdt_dt_tm: Option<String>,
}

impl SettlementDateTimeIndication1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SettlementFailsCurrency2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementFailsCurrency2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ccy") )]
	pub ccy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Data") )]
	pub data: SettlementTotalData1,
}

impl SettlementFailsCurrency2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.ccy) {
			return Err(ValidationError::new(1005, "ccy does not match the required pattern".to_string()));
		}
		self.data.validate()?;
		Ok(())
	}
}


// SettlementFailsDailyCSD1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementFailsDailyCSD1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DataSetActn", skip_serializing_if = "Option::is_none") )]
	pub data_set_actn: Option<ReportPeriodActivity1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Data", skip_serializing_if = "Option::is_none") )]
	pub data: Option<SettlementFailsDailyCSD3>,
}

impl SettlementFailsDailyCSD1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.data_set_actn { val.validate()? }
		if let Some(ref val) = self.data { val.validate()? }
		Ok(())
	}
}


// SettlementFailsDailyCSD3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementFailsDailyCSD3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntraCSD") )]
	pub intra_csd: SettlementFailsDailyInstructionType1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CrossCSD") )]
	pub cross_csd: SettlementFailsDailyInstructionType1Choice,
}

impl SettlementFailsDailyCSD3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.intra_csd.validate()?;
		self.cross_csd.validate()?;
		Ok(())
	}
}


// SettlementFailsDailyData3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementFailsDailyData3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgDt") )]
	pub rptg_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DalyRcrd") )]
	pub daly_rcrd: SettlementFailsDailyInstrument3,
}

impl SettlementFailsDailyData3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.daly_rcrd.validate()?;
		Ok(())
	}
}


// SettlementFailsDailyInstructionType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementFailsDailyInstructionType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DataSetActn", skip_serializing_if = "Option::is_none") )]
	pub data_set_actn: Option<ReportPeriodActivity1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Data", skip_serializing_if = "Option::is_none") )]
	pub data: Option<SettlementFailsDailyInstructionType3>,
}

impl SettlementFailsDailyInstructionType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.data_set_actn { val.validate()? }
		if let Some(ref val) = self.data { val.validate()? }
		Ok(())
	}
}


// SettlementFailsDailyInstructionType3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementFailsDailyInstructionType3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DlvryVrssPmt") )]
	pub dlvry_vrss_pmt: SettlementDailyFailureReason1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DlvryWthPmt") )]
	pub dlvry_wth_pmt: SettlementDailyFailureReason1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtFreeOfDlvry") )]
	pub pmt_free_of_dlvry: SettlementDailyFailureReason1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FreeOfPmt") )]
	pub free_of_pmt: SettlementDailyFailureReason1Choice,
}

impl SettlementFailsDailyInstructionType3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.dlvry_vrss_pmt.validate()?;
		self.dlvry_wth_pmt.validate()?;
		self.pmt_free_of_dlvry.validate()?;
		self.free_of_pmt.validate()?;
		Ok(())
	}
}


// SettlementFailsDailyInstrument3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementFailsDailyInstrument3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Eqty") )]
	pub eqty: SettlementFailsDailyTransactionType1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SvrgnDebt") )]
	pub svrgn_debt: SettlementFailsDailyTransactionType1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Bd") )]
	pub bd: SettlementFailsDailyTransactionType1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrTrfblScties") )]
	pub othr_trfbl_scties: SettlementFailsDailyTransactionType1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XchgTraddFnds") )]
	pub xchg_tradd_fnds: SettlementFailsDailyTransactionType1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CllctvInvstmtUdrtkgs") )]
	pub cllctv_invstmt_udrtkgs: SettlementFailsDailyTransactionType1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MnyMktInstrm") )]
	pub mny_mkt_instrm: SettlementFailsDailyTransactionType1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EmssnAllwnc") )]
	pub emssn_allwnc: SettlementFailsDailyTransactionType1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr") )]
	pub othr: SettlementFailsDailyTransactionType1Choice,
}

impl SettlementFailsDailyInstrument3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.eqty.validate()?;
		self.svrgn_debt.validate()?;
		self.bd.validate()?;
		self.othr_trfbl_scties.validate()?;
		self.xchg_tradd_fnds.validate()?;
		self.cllctv_invstmt_udrtkgs.validate()?;
		self.mny_mkt_instrm.validate()?;
		self.emssn_allwnc.validate()?;
		self.othr.validate()?;
		Ok(())
	}
}


// SettlementFailsDailyTransactionType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementFailsDailyTransactionType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DataSetActn", skip_serializing_if = "Option::is_none") )]
	pub data_set_actn: Option<ReportPeriodActivity1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Data", skip_serializing_if = "Option::is_none") )]
	pub data: Option<SettlementFailsDailyTransactionType3>,
}

impl SettlementFailsDailyTransactionType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.data_set_actn { val.validate()? }
		if let Some(ref val) = self.data { val.validate()? }
		Ok(())
	}
}


// SettlementFailsDailyTransactionType3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementFailsDailyTransactionType3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctiesBuyOrSell") )]
	pub scties_buy_or_sell: SettlementFailsDailyCSD1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollMgmtOpr") )]
	pub coll_mgmt_opr: SettlementFailsDailyCSD1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctiesLndgOrBrrwg") )]
	pub scties_lndg_or_brrwg: SettlementFailsDailyCSD1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RpAgrmt") )]
	pub rp_agrmt: SettlementFailsDailyCSD1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr") )]
	pub othr: SettlementFailsDailyCSD1Choice,
}

impl SettlementFailsDailyTransactionType3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.scties_buy_or_sell.validate()?;
		self.coll_mgmt_opr.validate()?;
		self.scties_lndg_or_brrwg.validate()?;
		self.rp_agrmt.validate()?;
		self.othr.validate()?;
		Ok(())
	}
}


// SettlementFailsData3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementFailsData3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ttl") )]
	pub ttl: SettlementTotalData1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtcptInFail", skip_serializing_if = "Option::is_none") )]
	pub ptcpt_in_fail: Option<SettlementFailsParticipantRange1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FlsPerCcy", skip_serializing_if = "Option::is_none") )]
	pub fls_per_ccy: Option<Vec<SettlementFailsCurrency2>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FlsPerFinInstrmTp", skip_serializing_if = "Option::is_none") )]
	pub fls_per_fin_instrm_tp: Option<SettlementFailsInstrument2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctiesInFail", skip_serializing_if = "Option::is_none") )]
	pub scties_in_fail: Option<SettlementFailsSecuritiesRange1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FlsPerTxTp", skip_serializing_if = "Option::is_none") )]
	pub fls_per_tx_tp: Option<SettlementFailsTransactionType2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlSttlmPnlties", skip_serializing_if = "Option::is_none") )]
	pub ttl_sttlm_pnlties: Option<SettlementDataVolume2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FailrRsn") )]
	pub failr_rsn: SettlementFailureReason3,
}

impl SettlementFailsData3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.ttl.validate()?;
		if let Some(ref val) = self.ptcpt_in_fail { val.validate()? }
		if let Some(ref vec) = self.fls_per_ccy { for item in vec { item.validate()? } }
		if let Some(ref val) = self.fls_per_fin_instrm_tp { val.validate()? }
		if let Some(ref val) = self.scties_in_fail { val.validate()? }
		if let Some(ref val) = self.fls_per_tx_tp { val.validate()? }
		if let Some(ref val) = self.ttl_sttlm_pnlties { val.validate()? }
		self.failr_rsn.validate()?;
		Ok(())
	}
}


// SettlementFailsData4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementFailsData4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ttl") )]
	pub ttl: SettlementTotalData1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FailrRsn") )]
	pub failr_rsn: SettlementFailureReason3,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ElgblForDrgtn") )]
	pub elgbl_for_drgtn: SettlementFailsDerogation1,
}

impl SettlementFailsData4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.ttl.validate()?;
		self.failr_rsn.validate()?;
		self.elgbl_for_drgtn.validate()?;
		Ok(())
	}
}


// SettlementFailsDerogation1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementFailsDerogation1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ElgbltyInd") )]
	pub elgblty_ind: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Justfn", skip_serializing_if = "Option::is_none") )]
	pub justfn: Option<SettlementFailsJustification1>,
}

impl SettlementFailsDerogation1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.justfn { val.validate()? }
		Ok(())
	}
}


// SettlementFailsInstrument2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementFailsInstrument2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Eqty") )]
	pub eqty: SettlementTotalData1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SvrgnDebt") )]
	pub svrgn_debt: SettlementTotalData1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Bd") )]
	pub bd: SettlementTotalData1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrTrfblScties") )]
	pub othr_trfbl_scties: SettlementTotalData1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XchgTraddFnds") )]
	pub xchg_tradd_fnds: SettlementTotalData1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CllctvInvstmtUdrtkgs") )]
	pub cllctv_invstmt_udrtkgs: SettlementTotalData1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MnyMktInstrm") )]
	pub mny_mkt_instrm: SettlementTotalData1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EmssnAllwnc") )]
	pub emssn_allwnc: SettlementTotalData1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr") )]
	pub othr: SettlementTotalData1Choice,
}

impl SettlementFailsInstrument2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.eqty.validate()?;
		self.svrgn_debt.validate()?;
		self.bd.validate()?;
		self.othr_trfbl_scties.validate()?;
		self.xchg_tradd_fnds.validate()?;
		self.cllctv_invstmt_udrtkgs.validate()?;
		self.mny_mkt_instrm.validate()?;
		self.emssn_allwnc.validate()?;
		self.othr.validate()?;
		Ok(())
	}
}


// SettlementFailsJustification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementFailsJustification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val") )]
	pub val: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rate") )]
	pub rate: SettlementDataRate1Choice,
}

impl SettlementFailsJustification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.rate.validate()?;
		Ok(())
	}
}


// SettlementFailsParticipant1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementFailsParticipant1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "LEI") )]
	pub lei: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rank") )]
	pub rank: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Aggt") )]
	pub aggt: SettlementTotalData1,
}

impl SettlementFailsParticipant1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
		if !pattern.is_match(&self.lei) {
			return Err(ValidationError::new(1005, "lei does not match the required pattern".to_string()));
		}
		let pattern = Regex::new("[0-9]{1,2}").unwrap();
		if !pattern.is_match(&self.rank) {
			return Err(ValidationError::new(1005, "rank does not match the required pattern".to_string()));
		}
		self.aggt.validate()?;
		Ok(())
	}
}


// SettlementFailsParticipantRange1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementFailsParticipantRange1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "HghstInVol") )]
	pub hghst_in_vol: Vec<SettlementFailsParticipant1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HghstInVal") )]
	pub hghst_in_val: Vec<SettlementFailsParticipant1>,
}

impl SettlementFailsParticipantRange1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		for item in &self.hghst_in_vol { item.validate()? }
		for item in &self.hghst_in_val { item.validate()? }
		Ok(())
	}
}


// SettlementFailsReportHeader2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementFailsReportHeader2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm") )]
	pub cre_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgPrd") )]
	pub rptg_prd: DatePeriod2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ccy") )]
	pub ccy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptSts") )]
	pub rpt_sts: TransactionOperationType4Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctiesSttlmSys") )]
	pub scties_sttlm_sys: SecuritiesSettlementSystemIdentification2,
}

impl SettlementFailsReportHeader2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.rptg_prd.validate()?;
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.ccy) {
			return Err(ValidationError::new(1005, "ccy does not match the required pattern".to_string()));
		}
		self.rpt_sts.validate()?;
		self.scties_sttlm_sys.validate()?;
		Ok(())
	}
}


// SettlementFailsSecurities1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementFailsSecurities1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmId") )]
	pub fin_instrm_id: SecurityIdentification19,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rank") )]
	pub rank: String,
}

impl SettlementFailsSecurities1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.fin_instrm_id.validate()?;
		let pattern = Regex::new("[0-9]{1,2}").unwrap();
		if !pattern.is_match(&self.rank) {
			return Err(ValidationError::new(1005, "rank does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// SettlementFailsSecuritiesRange1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementFailsSecuritiesRange1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "HghstInVol") )]
	pub hghst_in_vol: Vec<SettlementFailsSecurities1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HghstInVal") )]
	pub hghst_in_val: Vec<SettlementFailsSecurities1>,
}

impl SettlementFailsSecuritiesRange1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		for item in &self.hghst_in_vol { item.validate()? }
		for item in &self.hghst_in_val { item.validate()? }
		Ok(())
	}
}


// SettlementFailsTransactionType2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementFailsTransactionType2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctiesBuyOrSell") )]
	pub scties_buy_or_sell: SettlementTotalData1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollMgmtOpr") )]
	pub coll_mgmt_opr: SettlementTotalData1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctiesLndgOrBrrwg") )]
	pub scties_lndg_or_brrwg: SettlementTotalData1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RpAgrmt") )]
	pub rp_agrmt: SettlementTotalData1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr") )]
	pub othr: SettlementTotalData1Choice,
}

impl SettlementFailsTransactionType2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.scties_buy_or_sell.validate()?;
		self.coll_mgmt_opr.validate()?;
		self.scties_lndg_or_brrwg.validate()?;
		self.rp_agrmt.validate()?;
		self.othr.validate()?;
		Ok(())
	}
}


// SettlementFailureReason2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementFailureReason2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MainRsns") )]
	pub main_rsns: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EffcncyImprvmt") )]
	pub effcncy_imprvmt: String,
}

impl SettlementFailureReason2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.main_rsns.chars().count() < 1 {
			return Err(ValidationError::new(1001, "main_rsns is shorter than the minimum length of 1".to_string()));
		}
		if self.main_rsns.chars().count() > 2048 {
			return Err(ValidationError::new(1002, "main_rsns exceeds the maximum length of 2048".to_string()));
		}
		if self.effcncy_imprvmt.chars().count() < 1 {
			return Err(ValidationError::new(1001, "effcncy_imprvmt is shorter than the minimum length of 1".to_string()));
		}
		if self.effcncy_imprvmt.chars().count() > 2048 {
			return Err(ValidationError::new(1002, "effcncy_imprvmt exceeds the maximum length of 2048".to_string()));
		}
		Ok(())
	}
}


// SettlementFailureReason3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementFailureReason3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AvrgDrtn", skip_serializing_if = "Option::is_none") )]
	pub avrg_drtn: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Desc") )]
	pub desc: Vec<SettlementFailureReason2>,
}

impl SettlementFailureReason3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		for item in &self.desc { item.validate()? }
		Ok(())
	}
}


// SettlementFrequency1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementFrequency1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<EventFrequency10Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl SettlementFrequency1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// SettlementInformation17 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementInformation17 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctiesQtyTp", skip_serializing_if = "Option::is_none") )]
	pub scties_qty_tp: Option<SettlementUnitType3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctSttlmMnth", skip_serializing_if = "Option::is_none") )]
	pub ctrct_sttlm_mnth: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MinDnmtn", skip_serializing_if = "Option::is_none") )]
	pub min_dnmtn: Option<FinancialInstrumentQuantity1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MinMltplQty", skip_serializing_if = "Option::is_none") )]
	pub min_mltpl_qty: Option<FinancialInstrumentQuantity1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DevtgSttlmUnit", skip_serializing_if = "Option::is_none") )]
	pub devtg_sttlm_unit: Option<Vec<FinancialInstrumentQuantity1Choice>>,
}

impl SettlementInformation17 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.scties_qty_tp { val.validate()? }
		if let Some(ref val) = self.min_dnmtn { val.validate()? }
		if let Some(ref val) = self.min_mltpl_qty { val.validate()? }
		if let Some(ref vec) = self.devtg_sttlm_unit { for item in vec { item.validate()? } }
		Ok(())
	}
}


// SettlementInstruction11 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementInstruction11 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmMtd") )]
	pub sttlm_mtd: SettlementMethod1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmAcct", skip_serializing_if = "Option::is_none") )]
	pub sttlm_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrSys", skip_serializing_if = "Option::is_none") )]
	pub clr_sys: Option<ClearingSystemIdentification3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstgRmbrsmntAgt", skip_serializing_if = "Option::is_none") )]
	pub instg_rmbrsmnt_agt: Option<BranchAndFinancialInstitutionIdentification6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstgRmbrsmntAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub instg_rmbrsmnt_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstdRmbrsmntAgt", skip_serializing_if = "Option::is_none") )]
	pub instd_rmbrsmnt_agt: Option<BranchAndFinancialInstitutionIdentification6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstdRmbrsmntAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub instd_rmbrsmnt_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ThrdRmbrsmntAgt", skip_serializing_if = "Option::is_none") )]
	pub thrd_rmbrsmnt_agt: Option<BranchAndFinancialInstitutionIdentification6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ThrdRmbrsmntAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub thrd_rmbrsmnt_agt_acct: Option<CashAccount40>,
}

impl SettlementInstruction11 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.sttlm_mtd.validate()?;
		if let Some(ref val) = self.sttlm_acct { val.validate()? }
		if let Some(ref val) = self.clr_sys { val.validate()? }
		if let Some(ref val) = self.instg_rmbrsmnt_agt { val.validate()? }
		if let Some(ref val) = self.instg_rmbrsmnt_agt_acct { val.validate()? }
		if let Some(ref val) = self.instd_rmbrsmnt_agt { val.validate()? }
		if let Some(ref val) = self.instd_rmbrsmnt_agt_acct { val.validate()? }
		if let Some(ref val) = self.thrd_rmbrsmnt_agt { val.validate()? }
		if let Some(ref val) = self.thrd_rmbrsmnt_agt_acct { val.validate()? }
		Ok(())
	}
}


// SettlementInstruction14 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementInstruction14 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmMtd") )]
	pub sttlm_mtd: SettlementMethod2Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmAcct", skip_serializing_if = "Option::is_none") )]
	pub sttlm_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrSys", skip_serializing_if = "Option::is_none") )]
	pub clr_sys: Option<ClearingSystemIdentification3Choice>,
}

impl SettlementInstruction14 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.sttlm_mtd.validate()?;
		if let Some(ref val) = self.sttlm_acct { val.validate()? }
		if let Some(ref val) = self.clr_sys { val.validate()? }
		Ok(())
	}
}


// SettlementInstruction15 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementInstruction15 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmMtd") )]
	pub sttlm_mtd: SettlementMethod1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmAcct", skip_serializing_if = "Option::is_none") )]
	pub sttlm_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrSys", skip_serializing_if = "Option::is_none") )]
	pub clr_sys: Option<ClearingSystemIdentification3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstgRmbrsmntAgt", skip_serializing_if = "Option::is_none") )]
	pub instg_rmbrsmnt_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstgRmbrsmntAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub instg_rmbrsmnt_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstdRmbrsmntAgt", skip_serializing_if = "Option::is_none") )]
	pub instd_rmbrsmnt_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstdRmbrsmntAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub instd_rmbrsmnt_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ThrdRmbrsmntAgt", skip_serializing_if = "Option::is_none") )]
	pub thrd_rmbrsmnt_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ThrdRmbrsmntAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub thrd_rmbrsmnt_agt_acct: Option<CashAccount40>,
}

impl SettlementInstruction15 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.sttlm_mtd.validate()?;
		if let Some(ref val) = self.sttlm_acct { val.validate()? }
		if let Some(ref val) = self.clr_sys { val.validate()? }
		if let Some(ref val) = self.instg_rmbrsmnt_agt { val.validate()? }
		if let Some(ref val) = self.instg_rmbrsmnt_agt_acct { val.validate()? }
		if let Some(ref val) = self.instd_rmbrsmnt_agt { val.validate()? }
		if let Some(ref val) = self.instd_rmbrsmnt_agt_acct { val.validate()? }
		if let Some(ref val) = self.thrd_rmbrsmnt_agt { val.validate()? }
		if let Some(ref val) = self.thrd_rmbrsmnt_agt_acct { val.validate()? }
		Ok(())
	}
}


// SettlementInstruction16 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementInstruction16 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstgRmbrsmntAgt", skip_serializing_if = "Option::is_none") )]
	pub instg_rmbrsmnt_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstgRmbrsmntAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub instg_rmbrsmnt_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstdRmbrsmntAgt", skip_serializing_if = "Option::is_none") )]
	pub instd_rmbrsmnt_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstdRmbrsmntAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub instd_rmbrsmnt_agt_acct: Option<CashAccount40>,
}

impl SettlementInstruction16 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.instg_rmbrsmnt_agt { val.validate()? }
		if let Some(ref val) = self.instg_rmbrsmnt_agt_acct { val.validate()? }
		if let Some(ref val) = self.instd_rmbrsmnt_agt { val.validate()? }
		if let Some(ref val) = self.instd_rmbrsmnt_agt_acct { val.validate()? }
		Ok(())
	}
}


// SettlementInstructionReason1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementInstructionReason1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<SettlementInstructionReason1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl SettlementInstructionReason1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// SettlementInstructionReason1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum SettlementInstructionReason1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CSHI") )]
	CodeCSHI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ALLL") )]
	CodeALLL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CSHO") )]
	CodeCSHO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CHAR") )]
	CodeCHAR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DIVI") )]
	CodeDIVI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INTE") )]
	CodeINTE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SAVP") )]
	CodeSAVP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REDM") )]
	CodeREDM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SAVE") )]
	CodeSAVE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BUYI") )]
	CodeBUYI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SELL") )]
	CodeSELL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SUBS") )]
	CodeSUBS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WTHP") )]
	CodeWTHP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CORP") )]
	CodeCORP,
}

impl SettlementInstructionReason1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SettlementInternaliser1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementInternaliser1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: SettlementInternaliserIdentification1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OvrllTtl") )]
	pub ovrll_ttl: InternalisationData1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrm") )]
	pub fin_instrm: SettlementInternaliserFinancialInstrument1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxTp") )]
	pub tx_tp: SettlementInternaliserTransactionType1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClntTp") )]
	pub clnt_tp: SettlementInternaliserClientType1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlCshTrf") )]
	pub ttl_csh_trf: InternalisationData1,
}

impl SettlementInternaliser1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.id.validate()?;
		self.ovrll_ttl.validate()?;
		self.fin_instrm.validate()?;
		self.tx_tp.validate()?;
		self.clnt_tp.validate()?;
		self.ttl_csh_trf.validate()?;
		Ok(())
	}
}


// SettlementInternaliserClientType1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementInternaliserClientType1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prfssnl") )]
	pub prfssnl: InternalisationData1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rtl") )]
	pub rtl: InternalisationData1,
}

impl SettlementInternaliserClientType1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.prfssnl.validate()?;
		self.rtl.validate()?;
		Ok(())
	}
}


// SettlementInternaliserFinancialInstrument1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementInternaliserFinancialInstrument1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Eqty") )]
	pub eqty: InternalisationData1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SvrgnDebt") )]
	pub svrgn_debt: InternalisationData1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Bd") )]
	pub bd: InternalisationData1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrTrfblScties") )]
	pub othr_trfbl_scties: InternalisationData1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XchgTradgFnds") )]
	pub xchg_tradg_fnds: InternalisationData1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CllctvInvstmtUdrtkgs") )]
	pub cllctv_invstmt_udrtkgs: InternalisationData1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MnyMktInstrm") )]
	pub mny_mkt_instrm: InternalisationData1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EmssnAllwnc") )]
	pub emssn_allwnc: InternalisationData1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrFinInstrms") )]
	pub othr_fin_instrms: InternalisationData1,
}

impl SettlementInternaliserFinancialInstrument1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.eqty.validate()?;
		self.svrgn_debt.validate()?;
		self.bd.validate()?;
		self.othr_trfbl_scties.validate()?;
		self.xchg_tradg_fnds.validate()?;
		self.cllctv_invstmt_udrtkgs.validate()?;
		self.mny_mkt_instrm.validate()?;
		self.emssn_allwnc.validate()?;
		self.othr_fin_instrms.validate()?;
		Ok(())
	}
}


// SettlementInternaliserIdentification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementInternaliserIdentification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "LEI") )]
	pub lei: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RspnsblPrsn") )]
	pub rspnsbl_prsn: ContactDetails4,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctry") )]
	pub ctry: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BrnchId", skip_serializing_if = "Option::is_none") )]
	pub brnch_id: Option<String>,
}

impl SettlementInternaliserIdentification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
		if !pattern.is_match(&self.lei) {
			return Err(ValidationError::new(1005, "lei does not match the required pattern".to_string()));
		}
		self.rspnsbl_prsn.validate()?;
		let pattern = Regex::new("[A-Z]{2,2}").unwrap();
		if !pattern.is_match(&self.ctry) {
			return Err(ValidationError::new(1005, "ctry does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.brnch_id {
			let pattern = Regex::new("[A-Z]{2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "brnch_id does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// SettlementInternaliserReportHeader1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementInternaliserReportHeader1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm") )]
	pub cre_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgDt") )]
	pub rptg_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ccy") )]
	pub ccy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptSts") )]
	pub rpt_sts: TransactionOperationType4Code,
}

impl SettlementInternaliserReportHeader1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.ccy) {
			return Err(ValidationError::new(1005, "ccy does not match the required pattern".to_string()));
		}
		self.rpt_sts.validate()?;
		Ok(())
	}
}


// SettlementInternaliserTransactionType1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementInternaliserTransactionType1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctiesBuyOrSell") )]
	pub scties_buy_or_sell: InternalisationData1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollMgmtOpr") )]
	pub coll_mgmt_opr: InternalisationData1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctiesLndgOrBrrwg") )]
	pub scties_lndg_or_brrwg: InternalisationData1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RpAgrmt") )]
	pub rp_agrmt: InternalisationData1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrTxs") )]
	pub othr_txs: InternalisationData1,
}

impl SettlementInternaliserTransactionType1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.scties_buy_or_sell.validate()?;
		self.coll_mgmt_opr.validate()?;
		self.scties_lndg_or_brrwg.validate()?;
		self.rp_agrmt.validate()?;
		self.othr_txs.validate()?;
		Ok(())
	}
}


// SettlementMethod1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum SettlementMethod1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "INDA") )]
	CodeINDA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INGA") )]
	CodeINGA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "COVE") )]
	CodeCOVE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CLRG") )]
	CodeCLRG,
}

impl SettlementMethod1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SettlementMethod2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum SettlementMethod2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "INDA") )]
	CodeINDA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INGA") )]
	CodeINGA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CLRG") )]
	CodeCLRG,
}

impl SettlementMethod2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SettlementMethod5Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementMethod5Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cdt", skip_serializing_if = "Option::is_none") )]
	pub cdt: Option<CreditTransferTransaction59>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dbt", skip_serializing_if = "Option::is_none") )]
	pub dbt: Option<CreditTransferTransaction59>,
}

impl SettlementMethod5Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cdt { val.validate()? }
		if let Some(ref val) = self.dbt { val.validate()? }
		Ok(())
	}
}


// SettlementParties120 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementParties120 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DlvryAgt", skip_serializing_if = "Option::is_none") )]
	pub dlvry_agt: Option<PartyIdentification242Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Intrmy", skip_serializing_if = "Option::is_none") )]
	pub intrmy: Option<PartyIdentification242Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RcvgAgt") )]
	pub rcvg_agt: PartyIdentification242Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BnfcryInstn", skip_serializing_if = "Option::is_none") )]
	pub bnfcry_instn: Option<PartyIdentification242Choice>,
}

impl SettlementParties120 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.dlvry_agt { val.validate()? }
		if let Some(ref val) = self.intrmy { val.validate()? }
		self.rcvg_agt.validate()?;
		if let Some(ref val) = self.bnfcry_instn { val.validate()? }
		Ok(())
	}
}


// SettlementParties32 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementParties32 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dpstry") )]
	pub dpstry: PartyIdentification63,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pty1", skip_serializing_if = "Option::is_none") )]
	pub pty1: Option<PartyIdentificationAndAccount95>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pty2", skip_serializing_if = "Option::is_none") )]
	pub pty2: Option<PartyIdentificationAndAccount95>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pty3", skip_serializing_if = "Option::is_none") )]
	pub pty3: Option<PartyIdentificationAndAccount95>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pty4", skip_serializing_if = "Option::is_none") )]
	pub pty4: Option<PartyIdentificationAndAccount95>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pty5", skip_serializing_if = "Option::is_none") )]
	pub pty5: Option<PartyIdentificationAndAccount95>,
}

impl SettlementParties32 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.dpstry.validate()?;
		if let Some(ref val) = self.pty1 { val.validate()? }
		if let Some(ref val) = self.pty2 { val.validate()? }
		if let Some(ref val) = self.pty3 { val.validate()? }
		if let Some(ref val) = self.pty4 { val.validate()? }
		if let Some(ref val) = self.pty5 { val.validate()? }
		Ok(())
	}
}


// SettlementParties34Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementParties34Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CntrlSctiesDpstryPtcpt", skip_serializing_if = "Option::is_none") )]
	pub cntrl_scties_dpstry_ptcpt: Option<OrganisationIdentification15Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IndrctPtcpt", skip_serializing_if = "Option::is_none") )]
	pub indrct_ptcpt: Option<OrganisationIdentification15Choice>,
}

impl SettlementParties34Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cntrl_scties_dpstry_ptcpt { val.validate()? }
		if let Some(ref val) = self.indrct_ptcpt { val.validate()? }
		Ok(())
	}
}


// SettlementParties35 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementParties35 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "StgSttlmPties") )]
	pub stg_sttlm_pties: SettlementParties32,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LclMktId", skip_serializing_if = "Option::is_none") )]
	pub lcl_mkt_id: Option<Vec<GenericIdentification49>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegnDtls", skip_serializing_if = "Option::is_none") )]
	pub regn_dtls: Option<PartyIdentification99Choice>,
}

impl SettlementParties35 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.stg_sttlm_pties.validate()?;
		if let Some(ref vec) = self.lcl_mkt_id { for item in vec { item.validate()? } }
		if let Some(ref val) = self.regn_dtls { val.validate()? }
		Ok(())
	}
}


// SettlementStatus16Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementStatus16Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pdg", skip_serializing_if = "Option::is_none") )]
	pub pdg: Option<PendingStatus36Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Flng", skip_serializing_if = "Option::is_none") )]
	pub flng: Option<FailingStatus9Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<ProprietaryStatusAndReason6>,
}

impl SettlementStatus16Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.pdg { val.validate()? }
		if let Some(ref val) = self.flng { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// SettlementStatus26Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementStatus26Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<SecuritiesSettlementStatus1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl SettlementStatus26Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// SettlementSubTotalCalculatedTax2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementSubTotalCalculatedTax2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TpCd", skip_serializing_if = "Option::is_none") )]
	pub tp_cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClctdRate", skip_serializing_if = "Option::is_none") )]
	pub clctd_rate: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BsisAmt", skip_serializing_if = "Option::is_none") )]
	pub bsis_amt: Option<Vec<CurrencyAndAmount>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClctdAmt", skip_serializing_if = "Option::is_none") )]
	pub clctd_amt: Option<Vec<CurrencyAndAmount>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XmptnRsnCd", skip_serializing_if = "Option::is_none") )]
	pub xmptn_rsn_cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XmptnRsnTxt", skip_serializing_if = "Option::is_none") )]
	pub xmptn_rsn_txt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxCcyXchg", skip_serializing_if = "Option::is_none") )]
	pub tax_ccy_xchg: Option<CurrencyReference3>,
}

impl SettlementSubTotalCalculatedTax2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tp_cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tp_cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "tp_cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref vec) = self.bsis_amt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.clctd_amt { for item in vec { item.validate()? } }
		if let Some(ref val) = self.xmptn_rsn_cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "xmptn_rsn_cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "xmptn_rsn_cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.xmptn_rsn_txt {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "xmptn_rsn_txt is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 500 {
				return Err(ValidationError::new(1002, "xmptn_rsn_txt exceeds the maximum length of 500".to_string()));
			}
		}
		if let Some(ref val) = self.tax_ccy_xchg { val.validate()? }
		Ok(())
	}
}


// SettlementTimeRequest2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementTimeRequest2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CLSTm", skip_serializing_if = "Option::is_none") )]
	pub cls_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TillTm", skip_serializing_if = "Option::is_none") )]
	pub till_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrTm", skip_serializing_if = "Option::is_none") )]
	pub fr_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RjctTm", skip_serializing_if = "Option::is_none") )]
	pub rjct_tm: Option<String>,
}

impl SettlementTimeRequest2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SettlementTotalData1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementTotalData1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sttld") )]
	pub sttld: SettlementDataVolume2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Faild") )]
	pub faild: SettlementDataVolume2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ttl") )]
	pub ttl: SettlementDataVolume2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FaildRate") )]
	pub faild_rate: SettlementDataRate2,
}

impl SettlementTotalData1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.sttld.validate()?;
		self.faild.validate()?;
		self.ttl.validate()?;
		self.faild_rate.validate()?;
		Ok(())
	}
}


// SettlementTotalData1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementTotalData1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DataSetActn", skip_serializing_if = "Option::is_none") )]
	pub data_set_actn: Option<ReportPeriodActivity1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Data", skip_serializing_if = "Option::is_none") )]
	pub data: Option<SettlementTotalData1>,
}

impl SettlementTotalData1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.data_set_actn { val.validate()? }
		if let Some(ref val) = self.data { val.validate()? }
		Ok(())
	}
}


// SettlementType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum SettlementType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRIN") )]
	CodePRIN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NETO") )]
	CodeNETO,
}

impl SettlementType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SettlementType3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementType3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<SettlementType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl SettlementType3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// SettlementUnitType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum SettlementUnitType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "FAMT") )]
	CodeFAMT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UNIT") )]
	CodeUNIT,
}

impl SettlementUnitType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SettlementUnitType3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SettlementUnitType3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<SettlementUnitType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl SettlementUnitType3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// ShipmentAttribute2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ShipmentAttribute2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Conds", skip_serializing_if = "Option::is_none") )]
	pub conds: Option<ShipmentCondition1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XpctdDt", skip_serializing_if = "Option::is_none") )]
	pub xpctd_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtryOfCntrPty", skip_serializing_if = "Option::is_none") )]
	pub ctry_of_cntr_pty: Option<String>,
}

impl ShipmentAttribute2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.conds { val.validate()? }
		if let Some(ref val) = self.ctry_of_cntr_pty {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry_of_cntr_pty does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// ShipmentCondition1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ShipmentCondition1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl ShipmentCondition1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// ShipmentDateRange1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ShipmentDateRange1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "EarlstShipmntDt", skip_serializing_if = "Option::is_none") )]
	pub earlst_shipmnt_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LatstShipmntDt", skip_serializing_if = "Option::is_none") )]
	pub latst_shipmnt_dt: Option<String>,
}

impl ShipmentDateRange1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ShipmentDateRange2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ShipmentDateRange2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubQtyVal") )]
	pub sub_qty_val: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EarlstShipmntDt", skip_serializing_if = "Option::is_none") )]
	pub earlst_shipmnt_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LatstShipmntDt", skip_serializing_if = "Option::is_none") )]
	pub latst_shipmnt_dt: Option<String>,
}

impl ShipmentDateRange2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ShipmentSchedule2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ShipmentSchedule2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ShipmntDtRg", skip_serializing_if = "Option::is_none") )]
	pub shipmnt_dt_rg: Option<ShipmentDateRange1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ShipmntSubSchdl", skip_serializing_if = "Option::is_none") )]
	pub shipmnt_sub_schdl: Option<Vec<ShipmentDateRange2>>,
}

impl ShipmentSchedule2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.shipmnt_dt_rg { val.validate()? }
		if let Some(ref vec) = self.shipmnt_sub_schdl { for item in vec { item.validate()? } }
		Ok(())
	}
}


// ShortPaymentIdentification4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ShortPaymentIdentification4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxId", skip_serializing_if = "Option::is_none") )]
	pub tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UETR", skip_serializing_if = "Option::is_none") )]
	pub uetr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBkSttlmDt") )]
	pub intr_bk_sttlm_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstgAgt") )]
	pub instg_agt: BranchAndFinancialInstitutionIdentification8,
}

impl ShortPaymentIdentification4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.uetr {
			let pattern = Regex::new("[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "uetr does not match the required pattern".to_string()));
			}
		}
		self.instg_agt.validate()?;
		Ok(())
	}
}


// Side5Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum Side5Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "SESH") )]
	CodeSESH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SELL") )]
	CodeSELL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SSEX") )]
	CodeSSEX,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UNDI") )]
	CodeUNDI,
}

impl Side5Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Side6Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum Side6Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "BUYI") )]
	CodeBUYI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SELL") )]
	CodeSELL,
}

impl Side6Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SignatureEnvelope ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SignatureEnvelope {
}

impl SignatureEnvelope {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SignatureEnvelopeReference ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SignatureEnvelopeReference {
}

impl SignatureEnvelopeReference {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SignatureType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum SignatureType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ORIG") )]
	CodeORIG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DIGI") )]
	CodeDIGI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ELEC") )]
	CodeELEC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NONE") )]
	CodeNONE,
}

impl SignatureType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SimpleIdentificationInformation ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SimpleIdentificationInformation {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
}

impl SimpleIdentificationInformation {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		Ok(())
	}
}


// SimpleIdentificationInformation4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SimpleIdentificationInformation4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
}

impl SimpleIdentificationInformation4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		Ok(())
	}
}


// SkipPayload ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SkipPayload {
}

impl SkipPayload {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SpecialCollateral1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum SpecialCollateral1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "GENE") )]
	CodeGENE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SPEC") )]
	CodeSPEC,
}

impl SpecialCollateral1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SpecialCollateral2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum SpecialCollateral2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "GENE") )]
	CodeGENE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SPEC") )]
	CodeSPEC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MRRP") )]
	CodeMRRP,
}

impl SpecialCollateral2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SpecialCondition1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SpecialCondition1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "IncmgAmt") )]
	pub incmg_amt: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OutgngAmt") )]
	pub outgng_amt: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IncmgAmtToOthrAcct", skip_serializing_if = "Option::is_none") )]
	pub incmg_amt_to_othr_acct: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtFrOthrAcct", skip_serializing_if = "Option::is_none") )]
	pub pmt_fr_othr_acct: Option<ActiveCurrencyAndAmount>,
}

impl SpecialCondition1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.incmg_amt.validate()?;
		self.outgng_amt.validate()?;
		if let Some(ref val) = self.incmg_amt_to_othr_acct { val.validate()? }
		if let Some(ref val) = self.pmt_fr_othr_acct { val.validate()? }
		Ok(())
	}
}


// SpecialPurpose2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum SpecialPurpose2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "BLNK") )]
	CodeBLNK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NTAV") )]
	CodeNTAV,
}

impl SpecialPurpose2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SpecificCollateral2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SpecificCollateral2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmId") )]
	pub fin_instrm_id: FinancialInstrument59,
}

impl SpecificCollateral2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.fin_instrm_id.validate()?;
		Ok(())
	}
}


// SpecificCollateral3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SpecificCollateral3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmId") )]
	pub fin_instrm_id: FinancialInstrument104,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktVal") )]
	pub mkt_val: ActiveCurrencyAnd24Amount,
}

impl SpecificCollateral3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.fin_instrm_id.validate()?;
		self.mkt_val.validate()?;
		Ok(())
	}
}


// Standardisation1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum Standardisation1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "FLEX") )]
	CodeFLEX,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NSTA") )]
	CodeNSTA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "STAN") )]
	CodeSTAN,
}

impl Standardisation1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Standardisation3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Standardisation3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<Vec<Standardisation1Code>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl Standardisation3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.cd { for item in vec { item.validate()? } }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// StandingOrder10 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StandingOrder10 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<Amount2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cdtr", skip_serializing_if = "Option::is_none") )]
	pub cdtr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAcct", skip_serializing_if = "Option::is_none") )]
	pub cdtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dbtr", skip_serializing_if = "Option::is_none") )]
	pub dbtr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExctnTp", skip_serializing_if = "Option::is_none") )]
	pub exctn_tp: Option<ExecutionType1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Frqcy", skip_serializing_if = "Option::is_none") )]
	pub frqcy: Option<Frequency2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldtyPrd", skip_serializing_if = "Option::is_none") )]
	pub vldty_prd: Option<DatePeriod2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ZeroSweepInd", skip_serializing_if = "Option::is_none") )]
	pub zero_sweep_ind: Option<bool>,
}

impl StandingOrder10 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.amt { val.validate()? }
		if let Some(ref val) = self.cdtr { val.validate()? }
		if let Some(ref val) = self.cdtr_acct { val.validate()? }
		if let Some(ref val) = self.dbtr { val.validate()? }
		if let Some(ref val) = self.dbtr_acct { val.validate()? }
		if let Some(ref val) = self.exctn_tp { val.validate()? }
		if let Some(ref val) = self.frqcy { val.validate()? }
		if let Some(ref val) = self.vldty_prd { val.validate()? }
		Ok(())
	}
}


// StandingOrder11 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StandingOrder11 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: Amount2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbtInd") )]
	pub cdt_dbt_ind: CreditDebitCode,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ccy", skip_serializing_if = "Option::is_none") )]
	pub ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<StandingOrderType1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AssoctdPoolAcct", skip_serializing_if = "Option::is_none") )]
	pub assoctd_pool_acct: Option<AccountIdentification4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ref", skip_serializing_if = "Option::is_none") )]
	pub ref_attr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Frqcy", skip_serializing_if = "Option::is_none") )]
	pub frqcy: Option<Frequency2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldtyPrd", skip_serializing_if = "Option::is_none") )]
	pub vldty_prd: Option<DatePeriod3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SysMmb", skip_serializing_if = "Option::is_none") )]
	pub sys_mmb: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RspnsblPty", skip_serializing_if = "Option::is_none") )]
	pub rspnsbl_pty: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LkSetId", skip_serializing_if = "Option::is_none") )]
	pub lk_set_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LkSetOrdrId", skip_serializing_if = "Option::is_none") )]
	pub lk_set_ordr_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LkSetOrdrSeq", skip_serializing_if = "Option::is_none") )]
	pub lk_set_ordr_seq: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExctnTp", skip_serializing_if = "Option::is_none") )]
	pub exctn_tp: Option<ExecutionType1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cdtr", skip_serializing_if = "Option::is_none") )]
	pub cdtr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAcct", skip_serializing_if = "Option::is_none") )]
	pub cdtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dbtr", skip_serializing_if = "Option::is_none") )]
	pub dbtr: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlsPerStgOrdr", skip_serializing_if = "Option::is_none") )]
	pub ttls_per_stg_ordr: Option<StandingOrderTotalAmount1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ZeroSweepInd", skip_serializing_if = "Option::is_none") )]
	pub zero_sweep_ind: Option<bool>,
}

impl StandingOrder11 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.amt.validate()?;
		self.cdt_dbt_ind.validate()?;
		if let Some(ref val) = self.ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.assoctd_pool_acct { val.validate()? }
		if let Some(ref val) = self.ref_attr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ref_attr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "ref_attr exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.frqcy { val.validate()? }
		if let Some(ref val) = self.vldty_prd { val.validate()? }
		if let Some(ref val) = self.sys_mmb { val.validate()? }
		if let Some(ref val) = self.rspnsbl_pty { val.validate()? }
		if let Some(ref val) = self.lk_set_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "lk_set_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "lk_set_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.lk_set_ordr_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "lk_set_ordr_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "lk_set_ordr_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.exctn_tp { val.validate()? }
		if let Some(ref val) = self.cdtr { val.validate()? }
		if let Some(ref val) = self.cdtr_acct { val.validate()? }
		if let Some(ref val) = self.dbtr { val.validate()? }
		if let Some(ref val) = self.dbtr_acct { val.validate()? }
		if let Some(ref val) = self.ttls_per_stg_ordr { val.validate()? }
		Ok(())
	}
}


// StandingOrderCriteria5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StandingOrderCriteria5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NewQryNm", skip_serializing_if = "Option::is_none") )]
	pub new_qry_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SchCrit", skip_serializing_if = "Option::is_none") )]
	pub sch_crit: Option<Vec<StandingOrderSearchCriteria5>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RtrCrit", skip_serializing_if = "Option::is_none") )]
	pub rtr_crit: Option<StandingOrderReturnCriteria1>,
}

impl StandingOrderCriteria5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.new_qry_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "new_qry_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "new_qry_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref vec) = self.sch_crit { for item in vec { item.validate()? } }
		if let Some(ref val) = self.rtr_crit { val.validate()? }
		Ok(())
	}
}


// StandingOrderCriteria5Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StandingOrderCriteria5Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "QryNm", skip_serializing_if = "Option::is_none") )]
	pub qry_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NewCrit", skip_serializing_if = "Option::is_none") )]
	pub new_crit: Option<StandingOrderCriteria5>,
}

impl StandingOrderCriteria5Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.qry_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "qry_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "qry_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.new_crit { val.validate()? }
		Ok(())
	}
}


// StandingOrderIdentification8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StandingOrderIdentification8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Acct") )]
	pub acct: CashAccount40,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctOwnr", skip_serializing_if = "Option::is_none") )]
	pub acct_ownr: Option<BranchAndFinancialInstitutionIdentification8>,
}

impl StandingOrderIdentification8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
			}
		}
		self.acct.validate()?;
		if let Some(ref val) = self.acct_ownr { val.validate()? }
		Ok(())
	}
}


// StandingOrderIdentification9 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StandingOrderIdentification9 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Acct") )]
	pub acct: CashAccount40,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctOwnr", skip_serializing_if = "Option::is_none") )]
	pub acct_ownr: Option<BranchAndFinancialInstitutionIdentification8>,
}

impl StandingOrderIdentification9 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.acct.validate()?;
		if let Some(ref val) = self.acct_ownr { val.validate()? }
		Ok(())
	}
}


// StandingOrderOrAll4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StandingOrderOrAll4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "StgOrdr", skip_serializing_if = "Option::is_none") )]
	pub stg_ordr: Option<Vec<StandingOrderIdentification8>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AllStgOrdrs", skip_serializing_if = "Option::is_none") )]
	pub all_stg_ordrs: Option<Vec<StandingOrderIdentification9>>,
}

impl StandingOrderOrAll4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.stg_ordr { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.all_stg_ordrs { for item in vec { item.validate()? } }
		Ok(())
	}
}


// StandingOrderOrError10Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StandingOrderOrError10Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "StgOrdr", skip_serializing_if = "Option::is_none") )]
	pub stg_ordr: Option<StandingOrder11>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizErr", skip_serializing_if = "Option::is_none") )]
	pub biz_err: Option<Vec<ErrorHandling5>>,
}

impl StandingOrderOrError10Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.stg_ordr { val.validate()? }
		if let Some(ref vec) = self.biz_err { for item in vec { item.validate()? } }
		Ok(())
	}
}


// StandingOrderOrError9Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StandingOrderOrError9Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rpt", skip_serializing_if = "Option::is_none") )]
	pub rpt: Option<Vec<StandingOrderReport3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OprlErr", skip_serializing_if = "Option::is_none") )]
	pub oprl_err: Option<Vec<ErrorHandling5>>,
}

impl StandingOrderOrError9Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.rpt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.oprl_err { for item in vec { item.validate()? } }
		Ok(())
	}
}


// StandingOrderQuery5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StandingOrderQuery5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "QryTp", skip_serializing_if = "Option::is_none") )]
	pub qry_tp: Option<QueryType2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StgOrdrCrit", skip_serializing_if = "Option::is_none") )]
	pub stg_ordr_crit: Option<StandingOrderCriteria5Choice>,
}

impl StandingOrderQuery5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.qry_tp { val.validate()? }
		if let Some(ref val) = self.stg_ordr_crit { val.validate()? }
		Ok(())
	}
}


// StandingOrderQueryType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum StandingOrderQueryType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "SLST") )]
	CodeSLST,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SDTL") )]
	CodeSDTL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TAPS") )]
	CodeTAPS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SLSL") )]
	CodeSLSL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SWLS") )]
	CodeSWLS,
}

impl StandingOrderQueryType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// StandingOrderReport3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StandingOrderReport3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "StgOrdrId") )]
	pub stg_ordr_id: StandingOrderIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StgOrdrOrErr") )]
	pub stg_ordr_or_err: StandingOrderOrError10Choice,
}

impl StandingOrderReport3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.stg_ordr_id.validate()?;
		self.stg_ordr_or_err.validate()?;
		Ok(())
	}
}


// StandingOrderReturnCriteria1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StandingOrderReturnCriteria1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "StgOrdrIdInd", skip_serializing_if = "Option::is_none") )]
	pub stg_ordr_id_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TpInd", skip_serializing_if = "Option::is_none") )]
	pub tp_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SysMmbInd", skip_serializing_if = "Option::is_none") )]
	pub sys_mmb_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RspnsblPtyInd", skip_serializing_if = "Option::is_none") )]
	pub rspnsbl_pty_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CcyInd", skip_serializing_if = "Option::is_none") )]
	pub ccy_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAcctInd", skip_serializing_if = "Option::is_none") )]
	pub dbtr_acct_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAcctInd", skip_serializing_if = "Option::is_none") )]
	pub cdtr_acct_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AssoctdPoolAcct", skip_serializing_if = "Option::is_none") )]
	pub assoctd_pool_acct: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrqcyInd", skip_serializing_if = "Option::is_none") )]
	pub frqcy_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExctnTpInd", skip_serializing_if = "Option::is_none") )]
	pub exctn_tp_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldtyFrInd", skip_serializing_if = "Option::is_none") )]
	pub vldty_fr_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldToInd", skip_serializing_if = "Option::is_none") )]
	pub vld_to_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LkSetIdInd", skip_serializing_if = "Option::is_none") )]
	pub lk_set_id_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LkSetOrdrIdInd", skip_serializing_if = "Option::is_none") )]
	pub lk_set_ordr_id_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LkSetOrdrSeqInd", skip_serializing_if = "Option::is_none") )]
	pub lk_set_ordr_seq_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlAmtInd", skip_serializing_if = "Option::is_none") )]
	pub ttl_amt_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ZeroSweepInd", skip_serializing_if = "Option::is_none") )]
	pub zero_sweep_ind: Option<bool>,
}

impl StandingOrderReturnCriteria1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// StandingOrderSearchCriteria5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StandingOrderSearchCriteria5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "KeyAttrbtsInd", skip_serializing_if = "Option::is_none") )]
	pub key_attrbts_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StgOrdrId", skip_serializing_if = "Option::is_none") )]
	pub stg_ordr_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<StandingOrderType1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Acct", skip_serializing_if = "Option::is_none") )]
	pub acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ccy", skip_serializing_if = "Option::is_none") )]
	pub ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldtyPrd", skip_serializing_if = "Option::is_none") )]
	pub vldty_prd: Option<DatePeriod2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SysMmb", skip_serializing_if = "Option::is_none") )]
	pub sys_mmb: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RspnsblPty", skip_serializing_if = "Option::is_none") )]
	pub rspnsbl_pty: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AssoctdPoolAcct", skip_serializing_if = "Option::is_none") )]
	pub assoctd_pool_acct: Option<AccountIdentification4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LkSetId", skip_serializing_if = "Option::is_none") )]
	pub lk_set_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LkSetOrdrId", skip_serializing_if = "Option::is_none") )]
	pub lk_set_ordr_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LkSetOrdrSeq", skip_serializing_if = "Option::is_none") )]
	pub lk_set_ordr_seq: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ZeroSweepInd", skip_serializing_if = "Option::is_none") )]
	pub zero_sweep_ind: Option<bool>,
}

impl StandingOrderSearchCriteria5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.stg_ordr_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "stg_ordr_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "stg_ordr_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.acct { val.validate()? }
		if let Some(ref val) = self.ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.vldty_prd { val.validate()? }
		if let Some(ref val) = self.sys_mmb { val.validate()? }
		if let Some(ref val) = self.rspnsbl_pty { val.validate()? }
		if let Some(ref val) = self.assoctd_pool_acct { val.validate()? }
		if let Some(ref val) = self.lk_set_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "lk_set_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "lk_set_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.lk_set_ordr_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "lk_set_ordr_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "lk_set_ordr_id exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// StandingOrderTotalAmount1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StandingOrderTotalAmount1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SetPrdfndOrdr") )]
	pub set_prdfnd_ordr: TotalAmountAndCurrency1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PdgPrdfndOrdr") )]
	pub pdg_prdfnd_ordr: TotalAmountAndCurrency1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SetStgOrdr") )]
	pub set_stg_ordr: TotalAmountAndCurrency1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PdgStgOrdr") )]
	pub pdg_stg_ordr: TotalAmountAndCurrency1,
}

impl StandingOrderTotalAmount1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.set_prdfnd_ordr.validate()?;
		self.pdg_prdfnd_ordr.validate()?;
		self.set_stg_ordr.validate()?;
		self.pdg_stg_ordr.validate()?;
		Ok(())
	}
}


// StandingOrderType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StandingOrderType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<StandingOrderType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification1>,
}

impl StandingOrderType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// StandingOrderType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum StandingOrderType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "USTO") )]
	CodeUSTO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PSTO") )]
	CodePSTO,
}

impl StandingOrderType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// StatementFrequencyAndForm1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StatementFrequencyAndForm1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Frqcy") )]
	pub frqcy: Frequency7Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ComMtd") )]
	pub com_mtd: CommunicationMethod2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DlvryAdr") )]
	pub dlvry_adr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Frmt") )]
	pub frmt: CommunicationFormat1Choice,
}

impl StatementFrequencyAndForm1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.frqcy.validate()?;
		self.com_mtd.validate()?;
		if self.dlvry_adr.chars().count() < 1 {
			return Err(ValidationError::new(1001, "dlvry_adr is shorter than the minimum length of 1".to_string()));
		}
		if self.dlvry_adr.chars().count() > 350 {
			return Err(ValidationError::new(1002, "dlvry_adr exceeds the maximum length of 350".to_string()));
		}
		self.frmt.validate()?;
		Ok(())
	}
}


// StatementFrequencyAndFormModification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StatementFrequencyAndFormModification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModCd", skip_serializing_if = "Option::is_none") )]
	pub mod_cd: Option<Modification1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StmtFrqcyAndForm") )]
	pub stmt_frqcy_and_form: StatementFrequencyAndForm1,
}

impl StatementFrequencyAndFormModification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mod_cd { val.validate()? }
		self.stmt_frqcy_and_form.validate()?;
		Ok(())
	}
}


// StatementFrequencyReason2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StatementFrequencyReason2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<EventFrequency9Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl StatementFrequencyReason2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// StatementGroup5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StatementGroup5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "GrpId") )]
	pub grp_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sndr") )]
	pub sndr: PartyIdentification273,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SndrIndvCtct", skip_serializing_if = "Option::is_none") )]
	pub sndr_indv_ctct: Option<Vec<Contact13>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rcvr") )]
	pub rcvr: PartyIdentification273,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RcvrIndvCtct", skip_serializing_if = "Option::is_none") )]
	pub rcvr_indv_ctct: Option<Vec<Contact13>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BllgStmt") )]
	pub bllg_stmt: Vec<BillingStatement5>,
}

impl StatementGroup5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.grp_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "grp_id is shorter than the minimum length of 1".to_string()));
		}
		if self.grp_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "grp_id exceeds the maximum length of 35".to_string()));
		}
		self.sndr.validate()?;
		if let Some(ref vec) = self.sndr_indv_ctct { for item in vec { item.validate()? } }
		self.rcvr.validate()?;
		if let Some(ref vec) = self.rcvr_indv_ctct { for item in vec { item.validate()? } }
		for item in &self.bllg_stmt { item.validate()? }
		Ok(())
	}
}


// StatementResolutionEntry5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StatementResolutionEntry5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlGrpInf", skip_serializing_if = "Option::is_none") )]
	pub orgnl_grp_inf: Option<OriginalGroupInformation29>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlStmtId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_stmt_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UETR", skip_serializing_if = "Option::is_none") )]
	pub uetr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcrRef", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CrrctdAmt", skip_serializing_if = "Option::is_none") )]
	pub crrctd_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Chrgs", skip_serializing_if = "Option::is_none") )]
	pub chrgs: Option<Vec<Charges15>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Purp", skip_serializing_if = "Option::is_none") )]
	pub purp: Option<Purpose2Choice>,
}

impl StatementResolutionEntry5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgnl_grp_inf { val.validate()? }
		if let Some(ref val) = self.orgnl_stmt_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_stmt_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_stmt_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.uetr {
			let pattern = Regex::new("[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "uetr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.acct_svcr_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_svcr_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acct_svcr_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.crrctd_amt { val.validate()? }
		if let Some(ref vec) = self.chrgs { for item in vec { item.validate()? } }
		if let Some(ref val) = self.purp { val.validate()? }
		Ok(())
	}
}


// StatementUpdateType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum StatementUpdateType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "COMP") )]
	CodeCOMP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DELT") )]
	CodeDELT,
}

impl StatementUpdateType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// StatisticalReportingStatus1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum StatisticalReportingStatus1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACPT") )]
	CodeACPT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACTC") )]
	CodeACTC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PART") )]
	CodePART,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PDNG") )]
	CodePDNG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RCVD") )]
	CodeRCVD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RJCT") )]
	CodeRJCT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RMDR") )]
	CodeRMDR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INCF") )]
	CodeINCF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CRPT") )]
	CodeCRPT,
}

impl StatisticalReportingStatus1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// StatisticalReportingStatus2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum StatisticalReportingStatus2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACPT") )]
	CodeACPT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RJCT") )]
	CodeRJCT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WARN") )]
	CodeWARN,
}

impl StatisticalReportingStatus2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// StatisticsByPredefinedTimePeriods2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StatisticsByPredefinedTimePeriods2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "HghstPricVal12Mnths", skip_serializing_if = "Option::is_none") )]
	pub hghst_pric_val12_mnths: Option<PriceValue5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LwstPricVal12Mnths", skip_serializing_if = "Option::is_none") )]
	pub lwst_pric_val12_mnths: Option<PriceValue5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OneYrPricChng", skip_serializing_if = "Option::is_none") )]
	pub one_yr_pric_chng: Option<PriceValueChange1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ThreeYrPricChng", skip_serializing_if = "Option::is_none") )]
	pub three_yr_pric_chng: Option<PriceValueChange1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FiveYrPricChng", skip_serializing_if = "Option::is_none") )]
	pub five_yr_pric_chng: Option<PriceValueChange1>,
}

impl StatisticsByPredefinedTimePeriods2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.hghst_pric_val12_mnths { val.validate()? }
		if let Some(ref val) = self.lwst_pric_val12_mnths { val.validate()? }
		if let Some(ref val) = self.one_yr_pric_chng { val.validate()? }
		if let Some(ref val) = self.three_yr_pric_chng { val.validate()? }
		if let Some(ref val) = self.five_yr_pric_chng { val.validate()? }
		Ok(())
	}
}


// StatisticsByUserDefinedTimePeriod2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StatisticsByUserDefinedTimePeriod2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prd") )]
	pub prd: DateOrDateTimePeriodChoice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HghstPricVal", skip_serializing_if = "Option::is_none") )]
	pub hghst_pric_val: Option<PriceValue5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LwstPricVal", skip_serializing_if = "Option::is_none") )]
	pub lwst_pric_val: Option<PriceValue5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PricChng", skip_serializing_if = "Option::is_none") )]
	pub pric_chng: Option<PriceValueChange1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Yld", skip_serializing_if = "Option::is_none") )]
	pub yld: Option<f64>,
}

impl StatisticsByUserDefinedTimePeriod2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.prd.validate()?;
		if let Some(ref val) = self.hghst_pric_val { val.validate()? }
		if let Some(ref val) = self.lwst_pric_val { val.validate()? }
		if let Some(ref val) = self.pric_chng { val.validate()? }
		Ok(())
	}
}


// StatisticsPerCounterparty16Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StatisticsPerCounterparty16Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DataSetActn", skip_serializing_if = "Option::is_none") )]
	pub data_set_actn: Option<ReportPeriodActivity1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rpt", skip_serializing_if = "Option::is_none") )]
	pub rpt: Option<DetailedStatisticsPerCounterparty17>,
}

impl StatisticsPerCounterparty16Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.data_set_actn { val.validate()? }
		if let Some(ref val) = self.rpt { val.validate()? }
		Ok(())
	}
}


// StatisticsPerCounterparty18Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StatisticsPerCounterparty18Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DataSetActn", skip_serializing_if = "Option::is_none") )]
	pub data_set_actn: Option<ReportPeriodActivity1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rpt", skip_serializing_if = "Option::is_none") )]
	pub rpt: Option<DetailedStatisticsPerCounterparty19>,
}

impl StatisticsPerCounterparty18Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.data_set_actn { val.validate()? }
		if let Some(ref val) = self.rpt { val.validate()? }
		Ok(())
	}
}


// StatisticsPerCounterparty19Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StatisticsPerCounterparty19Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DataSetActn", skip_serializing_if = "Option::is_none") )]
	pub data_set_actn: Option<ReportPeriodActivity1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rpt", skip_serializing_if = "Option::is_none") )]
	pub rpt: Option<Vec<ReconciliationStatisticsPerCounterparty4>>,
}

impl StatisticsPerCounterparty19Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.data_set_actn { val.validate()? }
		if let Some(ref vec) = self.rpt { for item in vec { item.validate()? } }
		Ok(())
	}
}


// StatisticsTransparency2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StatisticsTransparency2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNbOfTxsExctd") )]
	pub ttl_nb_of_txs_exctd: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlVolOfTxsExctd") )]
	pub ttl_vol_of_txs_exctd: f64,
}

impl StatisticsTransparency2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// StatisticsTransparency3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StatisticsTransparency3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AvrgDalyTrnvr", skip_serializing_if = "Option::is_none") )]
	pub avrg_daly_trnvr: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AvrgTxVal", skip_serializing_if = "Option::is_none") )]
	pub avrg_tx_val: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LrgInScale", skip_serializing_if = "Option::is_none") )]
	pub lrg_in_scale: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StdMktSz", skip_serializing_if = "Option::is_none") )]
	pub std_mkt_sz: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AvrgDalyNbOfTxs", skip_serializing_if = "Option::is_none") )]
	pub avrg_daly_nb_of_txs: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNbOfTxsExctd", skip_serializing_if = "Option::is_none") )]
	pub ttl_nb_of_txs_exctd: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlVolOfTxsExctd", skip_serializing_if = "Option::is_none") )]
	pub ttl_vol_of_txs_exctd: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNbOfTradgDays", skip_serializing_if = "Option::is_none") )]
	pub ttl_nb_of_tradg_days: Option<f64>,
}

impl StatisticsTransparency3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.avrg_daly_trnvr { val.validate()? }
		if let Some(ref val) = self.avrg_tx_val { val.validate()? }
		Ok(())
	}
}


// Status25Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Status25Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts", skip_serializing_if = "Option::is_none") )]
	pub sts: Option<AccountManagementStatus1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rjctd", skip_serializing_if = "Option::is_none") )]
	pub rjctd: Option<Vec<RejectionReason31>>,
}

impl Status25Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.sts { val.validate()? }
		if let Some(ref vec) = self.rjctd { for item in vec { item.validate()? } }
		Ok(())
	}
}


// Status6Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum Status6Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "REJT") )]
	CodeREJT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "COMP") )]
	CodeCOMP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QUED") )]
	CodeQUED,
}

impl Status6Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// StatusAdviceReport3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StatusAdviceReport3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts") )]
	pub sts: ReportingMessageStatus1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldtnRule", skip_serializing_if = "Option::is_none") )]
	pub vldtn_rule: Option<Vec<GenericValidationRuleIdentification1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgDt", skip_serializing_if = "Option::is_none") )]
	pub msg_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sttstcs", skip_serializing_if = "Option::is_none") )]
	pub sttstcs: Option<OriginalReportStatistics3>,
}

impl StatusAdviceReport3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.sts.validate()?;
		if let Some(ref vec) = self.vldtn_rule { for item in vec { item.validate()? } }
		if let Some(ref val) = self.sttstcs { val.validate()? }
		Ok(())
	}
}


// StatusDetail1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StatusDetail1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctry", skip_serializing_if = "Option::is_none") )]
	pub ctry: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CmptntAuthrty") )]
	pub cmptnt_authrty: SupervisingAuthorityIdentification1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts", skip_serializing_if = "Option::is_none") )]
	pub sts: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StsRsn") )]
	pub sts_rsn: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ActvtyPrd", skip_serializing_if = "Option::is_none") )]
	pub actvty_prd: Option<Period4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cmnt", skip_serializing_if = "Option::is_none") )]
	pub cmnt: Option<String>,
}

impl StatusDetail1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ctry {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry does not match the required pattern".to_string()));
			}
		}
		self.cmptnt_authrty.validate()?;
		if let Some(ref val) = self.sts {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "sts is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 10 {
				return Err(ValidationError::new(1002, "sts exceeds the maximum length of 10".to_string()));
			}
		}
		if self.sts_rsn.chars().count() < 1 {
			return Err(ValidationError::new(1001, "sts_rsn is shorter than the minimum length of 1".to_string()));
		}
		if self.sts_rsn.chars().count() > 10 {
			return Err(ValidationError::new(1002, "sts_rsn exceeds the maximum length of 10".to_string()));
		}
		if let Some(ref val) = self.actvty_prd { val.validate()? }
		if let Some(ref val) = self.cmnt {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cmnt is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 20000 {
				return Err(ValidationError::new(1002, "cmnt exceeds the maximum length of 20000".to_string()));
			}
		}
		Ok(())
	}
}


// StatusReason6Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StatusReason6Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl StatusReason6Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// StatusReasonInformation10 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StatusReasonInformation10 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn") )]
	pub rsn: StatusReason6Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
}

impl StatusReasonInformation10 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.rsn.validate()?;
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// StatusReasonInformation12 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StatusReasonInformation12 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Orgtr", skip_serializing_if = "Option::is_none") )]
	pub orgtr: Option<PartyIdentification135>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<StatusReason6Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<Vec<String>>,
}

impl StatusReasonInformation12 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgtr { val.validate()? }
		if let Some(ref val) = self.rsn { val.validate()? }
		if let Some(ref vec) = self.addtl_inf {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 105 {
					return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 105".to_string()));
				}
			}
		}
		Ok(())
	}
}


// StatusReasonInformation14 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StatusReasonInformation14 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Orgtr", skip_serializing_if = "Option::is_none") )]
	pub orgtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<StatusReason6Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<Vec<String>>,
}

impl StatusReasonInformation14 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgtr { val.validate()? }
		if let Some(ref val) = self.rsn { val.validate()? }
		if let Some(ref vec) = self.addtl_inf {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 105 {
					return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 105".to_string()));
				}
			}
		}
		Ok(())
	}
}


// StatusReportRecord3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StatusReportRecord3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlRcrdId") )]
	pub orgnl_rcrd_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts") )]
	pub sts: ReportingRecordStatus1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldtnRule", skip_serializing_if = "Option::is_none") )]
	pub vldtn_rule: Option<Vec<GenericValidationRuleIdentification1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl StatusReportRecord3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.orgnl_rcrd_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "orgnl_rcrd_id is shorter than the minimum length of 1".to_string()));
		}
		if self.orgnl_rcrd_id.chars().count() > 140 {
			return Err(ValidationError::new(1002, "orgnl_rcrd_id exceeds the maximum length of 140".to_string()));
		}
		self.sts.validate()?;
		if let Some(ref vec) = self.vldtn_rule { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// StatusResponse1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum StatusResponse1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "NRES") )]
	CodeNRES,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PART") )]
	CodePART,
	#[cfg_attr( feature = "derive_serde", serde(rename = "COMP") )]
	CodeCOMP,
}

impl StatusResponse1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Strategy1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Strategy1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StrssSz") )]
	pub strss_sz: StressSize1Choice,
}

impl Strategy1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		self.strss_sz.validate()?;
		Ok(())
	}
}


// StrategyStressType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum StrategyStressType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "FLEX") )]
	CodeFLEX,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRLL") )]
	CodePRLL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SPRD") )]
	CodeSPRD,
}

impl StrategyStressType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// StressItem1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StressItem1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "StrssPdct") )]
	pub strss_pdct: StressItem1Choice,
}

impl StressItem1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.strss_pdct.validate()?;
		Ok(())
	}
}


// StressItem1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StressItem1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pdct", skip_serializing_if = "Option::is_none") )]
	pub pdct: Option<StressedProduct1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Strtgy", skip_serializing_if = "Option::is_none") )]
	pub strtgy: Option<Strategy1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RskFctr", skip_serializing_if = "Option::is_none") )]
	pub rsk_fctr: Option<RiskFactor1>,
}

impl StressItem1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.pdct { val.validate()? }
		if let Some(ref val) = self.strtgy { val.validate()? }
		if let Some(ref val) = self.rsk_fctr { val.validate()? }
		Ok(())
	}
}


// StressLiquidResourceRequirement1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StressLiquidResourceRequirement1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OprlOutflw") )]
	pub oprl_outflw: AmountAndDirection102,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VartnMrgnPmtOblgtn") )]
	pub vartn_mrgn_pmt_oblgtn: AmountAndDirection102,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmOrDlvry") )]
	pub sttlm_or_dlvry: AmountAndDirection102,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr") )]
	pub othr: AmountAndDirection102,
}

impl StressLiquidResourceRequirement1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.oprl_outflw.validate()?;
		self.vartn_mrgn_pmt_oblgtn.validate()?;
		self.sttlm_or_dlvry.validate()?;
		self.othr.validate()?;
		Ok(())
	}
}


// StressSize1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StressSize1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rltv", skip_serializing_if = "Option::is_none") )]
	pub rltv: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Abs", skip_serializing_if = "Option::is_none") )]
	pub abs: Option<Absolute1>,
}

impl StressSize1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.abs { val.validate()? }
		Ok(())
	}
}


// StressedProduct1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StressedProduct1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: GenericIdentification168,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MaxStrssSz") )]
	pub max_strss_sz: StressSize1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MinStrssSz") )]
	pub min_strss_sz: StressSize1Choice,
}

impl StressedProduct1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.id.validate()?;
		self.max_strss_sz.validate()?;
		self.min_strss_sz.validate()?;
		Ok(())
	}
}


// StructuredLongPostalAddress1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StructuredLongPostalAddress1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BldgNm", skip_serializing_if = "Option::is_none") )]
	pub bldg_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StrtNm", skip_serializing_if = "Option::is_none") )]
	pub strt_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StrtBldgId", skip_serializing_if = "Option::is_none") )]
	pub strt_bldg_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Flr", skip_serializing_if = "Option::is_none") )]
	pub flr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TwnNm") )]
	pub twn_nm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DstrctNm", skip_serializing_if = "Option::is_none") )]
	pub dstrct_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RgnId", skip_serializing_if = "Option::is_none") )]
	pub rgn_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Stat", skip_serializing_if = "Option::is_none") )]
	pub stat: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtyId", skip_serializing_if = "Option::is_none") )]
	pub cty_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctry") )]
	pub ctry: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstCdId") )]
	pub pst_cd_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "POB", skip_serializing_if = "Option::is_none") )]
	pub pob: Option<String>,
}

impl StructuredLongPostalAddress1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.bldg_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "bldg_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "bldg_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.strt_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "strt_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "strt_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.strt_bldg_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "strt_bldg_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "strt_bldg_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.flr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "flr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 16 {
				return Err(ValidationError::new(1002, "flr exceeds the maximum length of 16".to_string()));
			}
		}
		if self.twn_nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "twn_nm is shorter than the minimum length of 1".to_string()));
		}
		if self.twn_nm.chars().count() > 35 {
			return Err(ValidationError::new(1002, "twn_nm exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.dstrct_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "dstrct_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "dstrct_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.rgn_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rgn_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "rgn_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.stat {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "stat is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "stat exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.cty_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cty_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "cty_id exceeds the maximum length of 35".to_string()));
			}
		}
		let pattern = Regex::new("[A-Z]{2,2}").unwrap();
		if !pattern.is_match(&self.ctry) {
			return Err(ValidationError::new(1005, "ctry does not match the required pattern".to_string()));
		}
		if self.pst_cd_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "pst_cd_id is shorter than the minimum length of 1".to_string()));
		}
		if self.pst_cd_id.chars().count() > 16 {
			return Err(ValidationError::new(1002, "pst_cd_id exceeds the maximum length of 16".to_string()));
		}
		if let Some(ref val) = self.pob {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pob is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 16 {
				return Err(ValidationError::new(1002, "pob exceeds the maximum length of 16".to_string()));
			}
		}
		Ok(())
	}
}


// StructuredRegulatoryReporting3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StructuredRegulatoryReporting3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dt", skip_serializing_if = "Option::is_none") )]
	pub dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctry", skip_serializing_if = "Option::is_none") )]
	pub ctry: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Inf", skip_serializing_if = "Option::is_none") )]
	pub inf: Option<Vec<String>>,
}

impl StructuredRegulatoryReporting3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tp exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.ctry {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 10 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 10".to_string()));
			}
		}
		if let Some(ref val) = self.amt { val.validate()? }
		if let Some(ref vec) = self.inf {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "inf is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 35 {
					return Err(ValidationError::new(1002, "inf exceeds the maximum length of 35".to_string()));
				}
			}
		}
		Ok(())
	}
}


// StructuredRemittanceInformation16 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StructuredRemittanceInformation16 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RfrdDocInf", skip_serializing_if = "Option::is_none") )]
	pub rfrd_doc_inf: Option<Vec<ReferredDocumentInformation7>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RfrdDocAmt", skip_serializing_if = "Option::is_none") )]
	pub rfrd_doc_amt: Option<RemittanceAmount2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrRefInf", skip_serializing_if = "Option::is_none") )]
	pub cdtr_ref_inf: Option<CreditorReferenceInformation2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Invcr", skip_serializing_if = "Option::is_none") )]
	pub invcr: Option<PartyIdentification135>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Invcee", skip_serializing_if = "Option::is_none") )]
	pub invcee: Option<PartyIdentification135>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxRmt", skip_serializing_if = "Option::is_none") )]
	pub tax_rmt: Option<TaxInformation7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GrnshmtRmt", skip_serializing_if = "Option::is_none") )]
	pub grnshmt_rmt: Option<Garnishment3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlRmtInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_rmt_inf: Option<Vec<String>>,
}

impl StructuredRemittanceInformation16 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.rfrd_doc_inf { for item in vec { item.validate()? } }
		if let Some(ref val) = self.rfrd_doc_amt { val.validate()? }
		if let Some(ref val) = self.cdtr_ref_inf { val.validate()? }
		if let Some(ref val) = self.invcr { val.validate()? }
		if let Some(ref val) = self.invcee { val.validate()? }
		if let Some(ref val) = self.tax_rmt { val.validate()? }
		if let Some(ref val) = self.grnshmt_rmt { val.validate()? }
		if let Some(ref vec) = self.addtl_rmt_inf {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "addtl_rmt_inf is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 140 {
					return Err(ValidationError::new(1002, "addtl_rmt_inf exceeds the maximum length of 140".to_string()));
				}
			}
		}
		Ok(())
	}
}


// StructuredRemittanceInformation17 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StructuredRemittanceInformation17 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RfrdDocInf", skip_serializing_if = "Option::is_none") )]
	pub rfrd_doc_inf: Option<Vec<ReferredDocumentInformation7>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RfrdDocAmt", skip_serializing_if = "Option::is_none") )]
	pub rfrd_doc_amt: Option<RemittanceAmount2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrRefInf", skip_serializing_if = "Option::is_none") )]
	pub cdtr_ref_inf: Option<CreditorReferenceInformation2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Invcr", skip_serializing_if = "Option::is_none") )]
	pub invcr: Option<PartyIdentification135>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Invcee", skip_serializing_if = "Option::is_none") )]
	pub invcee: Option<PartyIdentification135>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxRmt", skip_serializing_if = "Option::is_none") )]
	pub tax_rmt: Option<TaxData1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GrnshmtRmt", skip_serializing_if = "Option::is_none") )]
	pub grnshmt_rmt: Option<Garnishment3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlRmtInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_rmt_inf: Option<Vec<String>>,
}

impl StructuredRemittanceInformation17 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.rfrd_doc_inf { for item in vec { item.validate()? } }
		if let Some(ref val) = self.rfrd_doc_amt { val.validate()? }
		if let Some(ref val) = self.cdtr_ref_inf { val.validate()? }
		if let Some(ref val) = self.invcr { val.validate()? }
		if let Some(ref val) = self.invcee { val.validate()? }
		if let Some(ref val) = self.tax_rmt { val.validate()? }
		if let Some(ref val) = self.grnshmt_rmt { val.validate()? }
		if let Some(ref vec) = self.addtl_rmt_inf {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "addtl_rmt_inf is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 140 {
					return Err(ValidationError::new(1002, "addtl_rmt_inf exceeds the maximum length of 140".to_string()));
				}
			}
		}
		Ok(())
	}
}


// StructuredRemittanceInformation18 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct StructuredRemittanceInformation18 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RfrdDocInf", skip_serializing_if = "Option::is_none") )]
	pub rfrd_doc_inf: Option<Vec<ReferredDocumentInformation8>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RfrdDocAmt", skip_serializing_if = "Option::is_none") )]
	pub rfrd_doc_amt: Option<RemittanceAmount4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrRefInf", skip_serializing_if = "Option::is_none") )]
	pub cdtr_ref_inf: Option<CreditorReferenceInformation3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Invcr", skip_serializing_if = "Option::is_none") )]
	pub invcr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Invcee", skip_serializing_if = "Option::is_none") )]
	pub invcee: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxRmt", skip_serializing_if = "Option::is_none") )]
	pub tax_rmt: Option<TaxData1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GrnshmtRmt", skip_serializing_if = "Option::is_none") )]
	pub grnshmt_rmt: Option<Garnishment4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlRmtInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_rmt_inf: Option<Vec<String>>,
}

impl StructuredRemittanceInformation18 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.rfrd_doc_inf { for item in vec { item.validate()? } }
		if let Some(ref val) = self.rfrd_doc_amt { val.validate()? }
		if let Some(ref val) = self.cdtr_ref_inf { val.validate()? }
		if let Some(ref val) = self.invcr { val.validate()? }
		if let Some(ref val) = self.invcee { val.validate()? }
		if let Some(ref val) = self.tax_rmt { val.validate()? }
		if let Some(ref val) = self.grnshmt_rmt { val.validate()? }
		if let Some(ref vec) = self.addtl_rmt_inf {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "addtl_rmt_inf is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 140 {
					return Err(ValidationError::new(1002, "addtl_rmt_inf exceeds the maximum length of 140".to_string()));
				}
			}
		}
		Ok(())
	}
}


// SupervisingAuthorityIdentification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SupervisingAuthorityIdentification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<SupervisingAuthorityIdentification1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LEI", skip_serializing_if = "Option::is_none") )]
	pub lei: Option<String>,
}

impl SupervisingAuthorityIdentification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.id { val.validate()? }
		if let Some(ref val) = self.lei {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "lei does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// SupervisingAuthorityIdentification1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SupervisingAuthorityIdentification1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtryId", skip_serializing_if = "Option::is_none") )]
	pub prtry_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FullNm", skip_serializing_if = "Option::is_none") )]
	pub full_nm: Option<String>,
}

impl SupervisingAuthorityIdentification1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.prtry_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "prtry_id exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.full_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "full_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "full_nm exceeds the maximum length of 350".to_string()));
			}
		}
		Ok(())
	}
}


// SupplementaryData1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SupplementaryData1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PlcAndNm", skip_serializing_if = "Option::is_none") )]
	pub plc_and_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Envlp") )]
	pub envlp: SupplementaryDataEnvelope1,
}

impl SupplementaryData1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.plc_and_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "plc_and_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "plc_and_nm exceeds the maximum length of 350".to_string()));
			}
		}
		self.envlp.validate()?;
		Ok(())
	}
}


// SupplementaryDataEnvelope1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SupplementaryDataEnvelope1 {
}

impl SupplementaryDataEnvelope1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SupportLetterType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SupportLetterType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl SupportLetterType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// SupportingDocument4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SupportingDocument4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SpprtgDocId") )]
	pub spprtg_doc_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlReqId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_req_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cert") )]
	pub cert: DocumentIdentification28,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctOwnr") )]
	pub acct_ownr: PartyIdentification272,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcr") )]
	pub acct_svcr: BranchAndFinancialInstitutionIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amdmnt", skip_serializing_if = "Option::is_none") )]
	pub amdmnt: Option<DocumentAmendment1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctRef") )]
	pub ctrct_ref: ContractRegistrationReference2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ntry") )]
	pub ntry: Vec<SupportingDocumentEntry2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl SupportingDocument4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.spprtg_doc_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "spprtg_doc_id is shorter than the minimum length of 1".to_string()));
		}
		if self.spprtg_doc_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "spprtg_doc_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.orgnl_req_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_req_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_req_id exceeds the maximum length of 35".to_string()));
			}
		}
		self.cert.validate()?;
		self.acct_ownr.validate()?;
		self.acct_svcr.validate()?;
		if let Some(ref val) = self.amdmnt { val.validate()? }
		self.ctrct_ref.validate()?;
		for item in &self.ntry { item.validate()? }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// SupportingDocumentEntry2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SupportingDocumentEntry2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtryId") )]
	pub ntry_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlDoc") )]
	pub orgnl_doc: DocumentIdentification22,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DocTp") )]
	pub doc_tp: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlAmt", skip_serializing_if = "Option::is_none") )]
	pub ttl_amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlAmtAftrShipmnt", skip_serializing_if = "Option::is_none") )]
	pub ttl_amt_aftr_shipmnt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlAmtInCtrctCcy", skip_serializing_if = "Option::is_none") )]
	pub ttl_amt_in_ctrct_ccy: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlAmtAftrShipmntInCtrctCcy", skip_serializing_if = "Option::is_none") )]
	pub ttl_amt_aftr_shipmnt_in_ctrct_ccy: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ShipmntAttrbts") )]
	pub shipmnt_attrbts: ShipmentAttribute2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtryAmdmntId", skip_serializing_if = "Option::is_none") )]
	pub ntry_amdmnt_id: Option<DocumentEntryAmendment1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MtrtyData", skip_serializing_if = "Option::is_none") )]
	pub mtrty_data: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Attchmnt", skip_serializing_if = "Option::is_none") )]
	pub attchmnt: Option<Vec<DocumentGeneralInformation5>>,
}

impl SupportingDocumentEntry2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.ntry_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "ntry_id is shorter than the minimum length of 1".to_string()));
		}
		if self.ntry_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "ntry_id exceeds the maximum length of 35".to_string()));
		}
		self.orgnl_doc.validate()?;
		let pattern = Regex::new("[a-zA-Z0-9]{1}[a-zA-Z0-9_]{3}").unwrap();
		if !pattern.is_match(&self.doc_tp) {
			return Err(ValidationError::new(1005, "doc_tp does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.ttl_amt { val.validate()? }
		if let Some(ref val) = self.ttl_amt_aftr_shipmnt { val.validate()? }
		if let Some(ref val) = self.ttl_amt_in_ctrct_ccy { val.validate()? }
		if let Some(ref val) = self.ttl_amt_aftr_shipmnt_in_ctrct_ccy { val.validate()? }
		self.shipmnt_attrbts.validate()?;
		if let Some(ref val) = self.ntry_amdmnt_id { val.validate()? }
		if let Some(ref val) = self.mtrty_data {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mtrty_data is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "mtrty_data exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 500 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 500".to_string()));
			}
		}
		if let Some(ref vec) = self.attchmnt { for item in vec { item.validate()? } }
		Ok(())
	}
}


// SupportingDocumentRequestOrLetter4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SupportingDocumentRequestOrLetter4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqOrLttrId") )]
	pub req_or_lttr_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dt", skip_serializing_if = "Option::is_none") )]
	pub dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sndr", skip_serializing_if = "Option::is_none") )]
	pub sndr: Option<Party50Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rcvr", skip_serializing_if = "Option::is_none") )]
	pub rcvr: Option<Party50Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlRefs", skip_serializing_if = "Option::is_none") )]
	pub orgnl_refs: Option<Vec<OriginalMessage6>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sbjt") )]
	pub sbjt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: SupportLetterType1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Desc", skip_serializing_if = "Option::is_none") )]
	pub desc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RspnReqrd") )]
	pub rspn_reqrd: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DueDt", skip_serializing_if = "Option::is_none") )]
	pub due_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Attchmnt", skip_serializing_if = "Option::is_none") )]
	pub attchmnt: Option<Vec<DocumentGeneralInformation5>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl SupportingDocumentRequestOrLetter4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.req_or_lttr_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "req_or_lttr_id is shorter than the minimum length of 1".to_string()));
		}
		if self.req_or_lttr_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "req_or_lttr_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.sndr { val.validate()? }
		if let Some(ref val) = self.rcvr { val.validate()? }
		if let Some(ref vec) = self.orgnl_refs { for item in vec { item.validate()? } }
		if self.sbjt.chars().count() < 1 {
			return Err(ValidationError::new(1001, "sbjt is shorter than the minimum length of 1".to_string()));
		}
		if self.sbjt.chars().count() > 140 {
			return Err(ValidationError::new(1002, "sbjt exceeds the maximum length of 140".to_string()));
		}
		self.tp.validate()?;
		if let Some(ref val) = self.desc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "desc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 1025 {
				return Err(ValidationError::new(1002, "desc exceeds the maximum length of 1025".to_string()));
			}
		}
		if let Some(ref vec) = self.attchmnt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// SuspendedStatusReason1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum SuspendedStatusReason1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "SUBY") )]
	CodeSUBY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SUBS") )]
	CodeSUBS,
}

impl SuspendedStatusReason1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SustainabilityPreferences2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum SustainabilityPreferences2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "NEUT") )]
	CodeNEUT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "YSCO") )]
	CodeYSCO,
}

impl SustainabilityPreferences2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SwapLegIdentification2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SwapLegIdentification2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SwpIn", skip_serializing_if = "Option::is_none") )]
	pub swp_in: Option<FinancialInstrumentIdentification7Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SwpOut", skip_serializing_if = "Option::is_none") )]
	pub swp_out: Option<FinancialInstrumentIdentification7Choice>,
}

impl SwapLegIdentification2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.swp_in { val.validate()? }
		if let Some(ref val) = self.swp_out { val.validate()? }
		Ok(())
	}
}


// SwapType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum SwapType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "OSSC") )]
	CodeOSSC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XFSC") )]
	CodeXFSC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XFMC") )]
	CodeXFMC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XXSC") )]
	CodeXXSC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XXMC") )]
	CodeXXMC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IFMC") )]
	CodeIFMC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FFSC") )]
	CodeFFSC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FFMC") )]
	CodeFFMC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IFSC") )]
	CodeIFSC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OSMC") )]
	CodeOSMC,
}

impl SwapType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SwitchStatus1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum SwitchStatus1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACPT") )]
	CodeACPT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BTRQ") )]
	CodeBTRQ,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BTRS") )]
	CodeBTRS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "COMP") )]
	CodeCOMP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REDT") )]
	CodeREDT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REDE") )]
	CodeREDE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REJT") )]
	CodeREJT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REQU") )]
	CodeREQU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TMTN") )]
	CodeTMTN,
}

impl SwitchStatus1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SwitchType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum SwitchType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "FULL") )]
	CodeFULL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PART") )]
	CodePART,
}

impl SwitchType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SyndicatedLoan3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SyndicatedLoan3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Brrwr") )]
	pub brrwr: TradeParty6,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Lndr", skip_serializing_if = "Option::is_none") )]
	pub lndr: Option<TradeParty6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Shr", skip_serializing_if = "Option::is_none") )]
	pub shr: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XchgRateInf", skip_serializing_if = "Option::is_none") )]
	pub xchg_rate_inf: Option<ExchangeRate1>,
}

impl SyndicatedLoan3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.brrwr.validate()?;
		if let Some(ref val) = self.lndr { val.validate()? }
		if let Some(ref val) = self.amt { val.validate()? }
		if let Some(ref val) = self.xchg_rate_inf { val.validate()? }
		Ok(())
	}
}


// System3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct System3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SysId", skip_serializing_if = "Option::is_none") )]
	pub sys_id: Option<MarketInfrastructureIdentification1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MmbId", skip_serializing_if = "Option::is_none") )]
	pub mmb_id: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctry", skip_serializing_if = "Option::is_none") )]
	pub ctry: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctId", skip_serializing_if = "Option::is_none") )]
	pub acct_id: Option<AccountIdentification4Choice>,
}

impl System3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.sys_id { val.validate()? }
		if let Some(ref val) = self.mmb_id { val.validate()? }
		if let Some(ref val) = self.ctry {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.acct_id { val.validate()? }
		Ok(())
	}
}


// SystemAndCurrency1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SystemAndCurrency1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SysId") )]
	pub sys_id: SystemIdentification2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SysCcy", skip_serializing_if = "Option::is_none") )]
	pub sys_ccy: Option<String>,
}

impl SystemAndCurrency1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.sys_id.validate()?;
		if let Some(ref val) = self.sys_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "sys_ccy does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// SystemAvailabilityAndEvents3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SystemAvailabilityAndEvents3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SysCcy", skip_serializing_if = "Option::is_none") )]
	pub sys_ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SsnPrd", skip_serializing_if = "Option::is_none") )]
	pub ssn_prd: Option<TimePeriod1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Evt", skip_serializing_if = "Option::is_none") )]
	pub evt: Option<Vec<SystemEvent3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClsrInf", skip_serializing_if = "Option::is_none") )]
	pub clsr_inf: Option<Vec<SystemClosure2>>,
}

impl SystemAvailabilityAndEvents3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.sys_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "sys_ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.ssn_prd { val.validate()? }
		if let Some(ref vec) = self.evt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.clsr_inf { for item in vec { item.validate()? } }
		Ok(())
	}
}


// SystemBalanceType2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum SystemBalanceType2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "OPNG") )]
	CodeOPNG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INTM") )]
	CodeINTM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CLSG") )]
	CodeCLSG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BOOK") )]
	CodeBOOK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CRRT") )]
	CodeCRRT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PDNG") )]
	CodePDNG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LRLD") )]
	CodeLRLD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AVLB") )]
	CodeAVLB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LTSF") )]
	CodeLTSF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CRDT") )]
	CodeCRDT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EAST") )]
	CodeEAST,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PYMT") )]
	CodePYMT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BLCK") )]
	CodeBLCK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XPCD") )]
	CodeXPCD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DLOD") )]
	CodeDLOD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XCRD") )]
	CodeXCRD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XDBT") )]
	CodeXDBT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ADJT") )]
	CodeADJT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRAV") )]
	CodePRAV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DBIT") )]
	CodeDBIT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "THRE") )]
	CodeTHRE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NOTE") )]
	CodeNOTE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FSET") )]
	CodeFSET,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BLOC") )]
	CodeBLOC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHB") )]
	CodeOTHB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CUST") )]
	CodeCUST,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FORC") )]
	CodeFORC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "COLC") )]
	CodeCOLC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FUND") )]
	CodeFUND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PIPO") )]
	CodePIPO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XCHG") )]
	CodeXCHG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CCPS") )]
	CodeCCPS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TOHB") )]
	CodeTOHB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "COHB") )]
	CodeCOHB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DOHB") )]
	CodeDOHB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TPBL") )]
	CodeTPBL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CPBL") )]
	CodeCPBL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DPBL") )]
	CodeDPBL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FUTB") )]
	CodeFUTB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REJB") )]
	CodeREJB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FCOL") )]
	CodeFCOL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FCOU") )]
	CodeFCOU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SCOL") )]
	CodeSCOL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SCOU") )]
	CodeSCOU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CUSA") )]
	CodeCUSA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XCHC") )]
	CodeXCHC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XCHN") )]
	CodeXCHN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DSET") )]
	CodeDSET,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LACK") )]
	CodeLACK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NSET") )]
	CodeNSET,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTCC") )]
	CodeOTCC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTCG") )]
	CodeOTCG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTCN") )]
	CodeOTCN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SAPD") )]
	CodeSAPD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SAPC") )]
	CodeSAPC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REPD") )]
	CodeREPD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REPC") )]
	CodeREPC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BSCD") )]
	CodeBSCD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BSCC") )]
	CodeBSCC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SAPP") )]
	CodeSAPP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IRLT") )]
	CodeIRLT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IRDR") )]
	CodeIRDR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DWRD") )]
	CodeDWRD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ADWR") )]
	CodeADWR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AIDR") )]
	CodeAIDR,
}

impl SystemBalanceType2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SystemClosure2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SystemClosure2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prd", skip_serializing_if = "Option::is_none") )]
	pub prd: Option<DateTimePeriod1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn") )]
	pub rsn: ClosureReason2Choice,
}

impl SystemClosure2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.prd { val.validate()? }
		self.rsn.validate()?;
		Ok(())
	}
}


// SystemClosureReason1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum SystemClosureReason1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "BHOL") )]
	CodeBHOL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SMTN") )]
	CodeSMTN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NOOP") )]
	CodeNOOP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RCVR") )]
	CodeRCVR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ADTW") )]
	CodeADTW,
}

impl SystemClosureReason1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SystemEvent3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SystemEvent3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: SystemEventType4Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SchdldTm") )]
	pub schdld_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FctvTm", skip_serializing_if = "Option::is_none") )]
	pub fctv_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StartTm", skip_serializing_if = "Option::is_none") )]
	pub start_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndTm", skip_serializing_if = "Option::is_none") )]
	pub end_tm: Option<String>,
}

impl SystemEvent3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tp.validate()?;
		Ok(())
	}
}


// SystemEventType2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SystemEventType2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<SystemEventType2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification1>,
}

impl SystemEventType2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// SystemEventType2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum SystemEventType2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "LVCO") )]
	CodeLVCO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LVCC") )]
	CodeLVCC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LVRT") )]
	CodeLVRT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EUSU") )]
	CodeEUSU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "STSU") )]
	CodeSTSU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LWSU") )]
	CodeLWSU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EUCO") )]
	CodeEUCO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FIRE") )]
	CodeFIRE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "STDY") )]
	CodeSTDY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LTNC") )]
	CodeLTNC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CRCO") )]
	CodeCRCO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RECC") )]
	CodeRECC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LTGC") )]
	CodeLTGC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LTDC") )]
	CodeLTDC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CUSC") )]
	CodeCUSC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IBKC") )]
	CodeIBKC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SYSC") )]
	CodeSYSC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SSSC") )]
	CodeSSSC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REOP") )]
	CodeREOP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PCOT") )]
	CodePCOT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NPCT") )]
	CodeNPCT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ESTF") )]
	CodeESTF,
}

impl SystemEventType2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SystemEventType4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SystemEventType4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification1>,
}

impl SystemEventType4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// SystemIdentification2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SystemIdentification2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktInfrstrctrId", skip_serializing_if = "Option::is_none") )]
	pub mkt_infrstrctr_id: Option<MarketInfrastructureIdentification1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctry", skip_serializing_if = "Option::is_none") )]
	pub ctry: Option<String>,
}

impl SystemIdentification2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mkt_infrstrctr_id { val.validate()? }
		if let Some(ref val) = self.ctry {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// SystemMember3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SystemMember3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SysId", skip_serializing_if = "Option::is_none") )]
	pub sys_id: Option<SystemIdentification2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MmbId") )]
	pub mmb_id: MemberIdentification3Choice,
}

impl SystemMember3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.sys_id { val.validate()? }
		self.mmb_id.validate()?;
		Ok(())
	}
}


// SystemMemberStatus1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SystemMemberStatus1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<MemberStatus1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl SystemMemberStatus1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// SystemMemberType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SystemMemberType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl SystemMemberType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// SystemParty2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SystemParty2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OpngDt", skip_serializing_if = "Option::is_none") )]
	pub opng_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClsgDt", skip_serializing_if = "Option::is_none") )]
	pub clsg_dt: Option<String>,
}

impl SystemParty2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SystemParty6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SystemParty6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtyId", skip_serializing_if = "Option::is_none") )]
	pub pty_id: Option<SystemPartyIdentification9>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Adr", skip_serializing_if = "Option::is_none") )]
	pub adr: Option<PostalAddress28>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtctDtls", skip_serializing_if = "Option::is_none") )]
	pub ctct_dtls: Option<Vec<Contact14>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OpngDt", skip_serializing_if = "Option::is_none") )]
	pub opng_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClsgDt", skip_serializing_if = "Option::is_none") )]
	pub clsg_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<SystemPartyType1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechAdr", skip_serializing_if = "Option::is_none") )]
	pub tech_adr: Option<Vec<TechnicalIdentification2Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktSpcfcAttr", skip_serializing_if = "Option::is_none") )]
	pub mkt_spcfc_attr: Option<Vec<MarketSpecificAttribute1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<PartyName4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ResTp", skip_serializing_if = "Option::is_none") )]
	pub res_tp: Option<ResidenceType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LckSts", skip_serializing_if = "Option::is_none") )]
	pub lck_sts: Option<PartyLockStatus1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rstrctn", skip_serializing_if = "Option::is_none") )]
	pub rstrctn: Option<Vec<SystemRestriction1>>,
}

impl SystemParty6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.pty_id { val.validate()? }
		if let Some(ref val) = self.adr { val.validate()? }
		if let Some(ref vec) = self.ctct_dtls { for item in vec { item.validate()? } }
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref vec) = self.tech_adr { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.mkt_spcfc_attr { for item in vec { item.validate()? } }
		if let Some(ref val) = self.nm { val.validate()? }
		if let Some(ref val) = self.res_tp { val.validate()? }
		if let Some(ref val) = self.lck_sts { val.validate()? }
		if let Some(ref vec) = self.rstrctn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// SystemParty7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SystemParty7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtyId") )]
	pub pty_id: SystemPartyIdentification9,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Adr", skip_serializing_if = "Option::is_none") )]
	pub adr: Option<Vec<PostalAddress28>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtctDtls", skip_serializing_if = "Option::is_none") )]
	pub ctct_dtls: Option<Vec<Contact14>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OpngDt", skip_serializing_if = "Option::is_none") )]
	pub opng_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClsgDt", skip_serializing_if = "Option::is_none") )]
	pub clsg_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: SystemPartyType1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechAdr", skip_serializing_if = "Option::is_none") )]
	pub tech_adr: Option<Vec<TechnicalIdentification2Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktSpcfcAttr", skip_serializing_if = "Option::is_none") )]
	pub mkt_spcfc_attr: Option<Vec<MarketSpecificAttribute1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<PartyName4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ResTp", skip_serializing_if = "Option::is_none") )]
	pub res_tp: Option<ResidenceType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LckSts", skip_serializing_if = "Option::is_none") )]
	pub lck_sts: Option<PartyLockStatus1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rstrctn", skip_serializing_if = "Option::is_none") )]
	pub rstrctn: Option<Vec<SystemRestriction1>>,
}

impl SystemParty7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pty_id.validate()?;
		if let Some(ref vec) = self.adr { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.ctct_dtls { for item in vec { item.validate()? } }
		self.tp.validate()?;
		if let Some(ref vec) = self.tech_adr { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.mkt_spcfc_attr { for item in vec { item.validate()? } }
		if let Some(ref val) = self.nm { val.validate()? }
		if let Some(ref val) = self.res_tp { val.validate()? }
		if let Some(ref val) = self.lck_sts { val.validate()? }
		if let Some(ref vec) = self.rstrctn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// SystemPartyIdentification10 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SystemPartyIdentification10 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldFr", skip_serializing_if = "Option::is_none") )]
	pub vld_fr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<PartyIdentification136>,
}

impl SystemPartyIdentification10 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.id { val.validate()? }
		Ok(())
	}
}


// SystemPartyIdentification2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SystemPartyIdentification2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgId", skip_serializing_if = "Option::is_none") )]
	pub org_id: Option<PartyIdentification136>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CmbndId", skip_serializing_if = "Option::is_none") )]
	pub cmbnd_id: Option<SystemPartyIdentification8>,
}

impl SystemPartyIdentification2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.org_id { val.validate()? }
		if let Some(ref val) = self.cmbnd_id { val.validate()? }
		Ok(())
	}
}


// SystemPartyIdentification8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SystemPartyIdentification8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: PartyIdentification136,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RspnsblPtyId", skip_serializing_if = "Option::is_none") )]
	pub rspnsbl_pty_id: Option<PartyIdentification136>,
}

impl SystemPartyIdentification8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.id.validate()?;
		if let Some(ref val) = self.rspnsbl_pty_id { val.validate()? }
		Ok(())
	}
}


// SystemPartyIdentification9 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SystemPartyIdentification9 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: PartyIdentification136,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RspnsblPtyId", skip_serializing_if = "Option::is_none") )]
	pub rspnsbl_pty_id: Option<PartyIdentification136>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldFr", skip_serializing_if = "Option::is_none") )]
	pub vld_fr: Option<String>,
}

impl SystemPartyIdentification9 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.id.validate()?;
		if let Some(ref val) = self.rspnsbl_pty_id { val.validate()? }
		Ok(())
	}
}


// SystemPartyModification3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SystemPartyModification3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ScpIndctn") )]
	pub scp_indctn: DataModification1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdMod") )]
	pub reqd_mod: SystemPartyModification3Choice,
}

impl SystemPartyModification3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.scp_indctn.validate()?;
		self.reqd_mod.validate()?;
		Ok(())
	}
}


// SystemPartyModification3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SystemPartyModification3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SysPtyDt", skip_serializing_if = "Option::is_none") )]
	pub sys_pty_dt: Option<SystemParty2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtyId", skip_serializing_if = "Option::is_none") )]
	pub pty_id: Option<SystemPartyIdentification10>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtyNm", skip_serializing_if = "Option::is_none") )]
	pub pty_nm: Option<PartyName3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtctDtls", skip_serializing_if = "Option::is_none") )]
	pub ctct_dtls: Option<Contact14>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechAdr", skip_serializing_if = "Option::is_none") )]
	pub tech_adr: Option<TechnicalIdentification2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtyAdr", skip_serializing_if = "Option::is_none") )]
	pub pty_adr: Option<PostalAddress28>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ResTp", skip_serializing_if = "Option::is_none") )]
	pub res_tp: Option<ResidenceType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LckSts", skip_serializing_if = "Option::is_none") )]
	pub lck_sts: Option<PartyLockStatus1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SysRstrctn", skip_serializing_if = "Option::is_none") )]
	pub sys_rstrctn: Option<SystemRestriction1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktSpcfcAttr", skip_serializing_if = "Option::is_none") )]
	pub mkt_spcfc_attr: Option<MarketSpecificAttribute1>,
}

impl SystemPartyModification3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.sys_pty_dt { val.validate()? }
		if let Some(ref val) = self.pty_id { val.validate()? }
		if let Some(ref val) = self.pty_nm { val.validate()? }
		if let Some(ref val) = self.ctct_dtls { val.validate()? }
		if let Some(ref val) = self.tech_adr { val.validate()? }
		if let Some(ref val) = self.pty_adr { val.validate()? }
		if let Some(ref val) = self.res_tp { val.validate()? }
		if let Some(ref val) = self.lck_sts { val.validate()? }
		if let Some(ref val) = self.sys_rstrctn { val.validate()? }
		if let Some(ref val) = self.mkt_spcfc_attr { val.validate()? }
		Ok(())
	}
}


// SystemPartyType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SystemPartyType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl SystemPartyType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// SystemRestriction1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SystemRestriction1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldFr") )]
	pub vld_fr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldTo", skip_serializing_if = "Option::is_none") )]
	pub vld_to: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: String,
}

impl SystemRestriction1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.tp.chars().count() < 1 {
			return Err(ValidationError::new(1001, "tp is shorter than the minimum length of 1".to_string()));
		}
		if self.tp.chars().count() > 35 {
			return Err(ValidationError::new(1002, "tp exceeds the maximum length of 35".to_string()));
		}
		Ok(())
	}
}


// SystemReturnCriteria2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SystemReturnCriteria2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SysIdInd", skip_serializing_if = "Option::is_none") )]
	pub sys_id_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MmbIdInd", skip_serializing_if = "Option::is_none") )]
	pub mmb_id_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtryIdInd", skip_serializing_if = "Option::is_none") )]
	pub ctry_id_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctIdInd", skip_serializing_if = "Option::is_none") )]
	pub acct_id_ind: Option<bool>,
}

impl SystemReturnCriteria2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SystemSearch5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SystemSearch5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "SysId", skip_serializing_if = "Option::is_none") )]
	pub sys_id: Option<Vec<ClearingSystemIdentification3Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MmbId", skip_serializing_if = "Option::is_none") )]
	pub mmb_id: Option<Vec<BranchAndFinancialInstitutionIdentification8>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctry", skip_serializing_if = "Option::is_none") )]
	pub ctry: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctId", skip_serializing_if = "Option::is_none") )]
	pub acct_id: Option<AccountIdentification4Choice>,
}

impl SystemSearch5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.sys_id { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.mmb_id { for item in vec { item.validate()? } }
		if let Some(ref val) = self.ctry {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ctry does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.acct_id { val.validate()? }
		Ok(())
	}
}


// SystemSecuritiesAccount5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SystemSecuritiesAccount5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClsgDt", skip_serializing_if = "Option::is_none") )]
	pub clsg_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HldInd", skip_serializing_if = "Option::is_none") )]
	pub hld_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NegPos", skip_serializing_if = "Option::is_none") )]
	pub neg_pos: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndInvstrFlg", skip_serializing_if = "Option::is_none") )]
	pub end_invstr_flg: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PricgSchme", skip_serializing_if = "Option::is_none") )]
	pub pricg_schme: Option<String>,
}

impl SystemSecuritiesAccount5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.end_invstr_flg {
			let pattern = Regex::new("[a-zA-Z0-9]{4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "end_invstr_flg does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.pricg_schme {
			let pattern = Regex::new("[a-zA-Z0-9]{4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "pricg_schme does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// SystemSecuritiesAccount6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SystemSecuritiesAccount6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OpngDt", skip_serializing_if = "Option::is_none") )]
	pub opng_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClsgDt", skip_serializing_if = "Option::is_none") )]
	pub clsg_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HldInd", skip_serializing_if = "Option::is_none") )]
	pub hld_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NegPos", skip_serializing_if = "Option::is_none") )]
	pub neg_pos: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<SystemSecuritiesAccountType1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctOwnr") )]
	pub acct_ownr: SystemPartyIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtyTp", skip_serializing_if = "Option::is_none") )]
	pub pty_tp: Option<SystemPartyType1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktSpcfcAttr", skip_serializing_if = "Option::is_none") )]
	pub mkt_spcfc_attr: Option<Vec<MarketSpecificAttribute1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rstrctn", skip_serializing_if = "Option::is_none") )]
	pub rstrctn: Option<Vec<SystemRestriction1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndInvstrFlg", skip_serializing_if = "Option::is_none") )]
	pub end_invstr_flg: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PricgSchme", skip_serializing_if = "Option::is_none") )]
	pub pricg_schme: Option<String>,
}

impl SystemSecuritiesAccount6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tp { val.validate()? }
		self.acct_ownr.validate()?;
		if let Some(ref val) = self.pty_tp { val.validate()? }
		if let Some(ref vec) = self.mkt_spcfc_attr { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.rstrctn { for item in vec { item.validate()? } }
		if let Some(ref val) = self.end_invstr_flg {
			let pattern = Regex::new("[a-zA-Z0-9]{4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "end_invstr_flg does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.pricg_schme {
			let pattern = Regex::new("[a-zA-Z0-9]{4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "pricg_schme does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// SystemSecuritiesAccount7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SystemSecuritiesAccount7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctOwnr") )]
	pub acct_ownr: SystemPartyIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: SystemSecuritiesAccountType1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OpngDt") )]
	pub opng_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClsgDt", skip_serializing_if = "Option::is_none") )]
	pub clsg_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HldInd") )]
	pub hld_ind: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NegPos") )]
	pub neg_pos: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktSpcfcAttr", skip_serializing_if = "Option::is_none") )]
	pub mkt_spcfc_attr: Option<Vec<MarketSpecificAttribute1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rstrctn", skip_serializing_if = "Option::is_none") )]
	pub rstrctn: Option<Vec<SystemRestriction1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndInvstrFlg", skip_serializing_if = "Option::is_none") )]
	pub end_invstr_flg: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PricgSchme", skip_serializing_if = "Option::is_none") )]
	pub pricg_schme: Option<String>,
}

impl SystemSecuritiesAccount7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.acct_ownr.validate()?;
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
		}
		self.tp.validate()?;
		if let Some(ref vec) = self.mkt_spcfc_attr { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.rstrctn { for item in vec { item.validate()? } }
		if let Some(ref val) = self.end_invstr_flg {
			let pattern = Regex::new("[a-zA-Z0-9]{4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "end_invstr_flg does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.pricg_schme {
			let pattern = Regex::new("[a-zA-Z0-9]{4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "pricg_schme does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// SystemSecuritiesAccountType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SystemSecuritiesAccountType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<SystemSecuritiesAccountType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl SystemSecuritiesAccountType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// SystemSecuritiesAccountType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum SystemSecuritiesAccountType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CSDP") )]
	CodeCSDP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CSDM") )]
	CodeCSDM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ICSA") )]
	CodeICSA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TOFF") )]
	CodeTOFF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CSDO") )]
	CodeCSDO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISSA") )]
	CodeISSA,
}

impl SystemSecuritiesAccountType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SystemStatus2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SystemStatus2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<SystemStatus2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification1>,
}

impl SystemStatus2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// SystemStatus2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum SystemStatus2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "SUSP") )]
	CodeSUSP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACTV") )]
	CodeACTV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CLSD") )]
	CodeCLSD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CLSG") )]
	CodeCLSG,
}

impl SystemStatus2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// SystemStatus3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SystemStatus3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts") )]
	pub sts: SystemStatus2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldtyTm", skip_serializing_if = "Option::is_none") )]
	pub vldty_tm: Option<DateTimePeriod1Choice>,
}

impl SystemStatus3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.sts.validate()?;
		if let Some(ref val) = self.vldty_tm { val.validate()? }
		Ok(())
	}
}


// SystemStatus3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct SystemStatus3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<SystemStatus3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification1>,
}

impl SystemStatus3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// SystemStatus3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum SystemStatus3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACTV") )]
	CodeACTV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CLSD") )]
	CodeCLSD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RMPS") )]
	CodeRMPS,
}

impl SystemStatus3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TEFRARules1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum TEFRARules1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "RULC") )]
	CodeRULC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RULD") )]
	CodeRULD,
}

impl TEFRARules1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TEFRARules3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TEFRARules3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<TEFRARules1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl TEFRARules3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// TargetMarket1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TargetMarket1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<TargetMarket1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl TargetMarket1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// TargetMarket1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum TargetMarket1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "YSCO") )]
	CodeYSCO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NEUT") )]
	CodeNEUT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NSCO") )]
	CodeNSCO,
}

impl TargetMarket1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TargetMarket2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum TargetMarket2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "NEUT") )]
	CodeNEUT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "YSCO") )]
	CodeYSCO,
}

impl TargetMarket2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TargetMarket3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TargetMarket3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<InvestorType2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<TargetMarket1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl TargetMarket3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.othr { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// TargetMarket3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum TargetMarket3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "YSCO") )]
	CodeYSCO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NSCO") )]
	CodeNSCO,
}

impl TargetMarket3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TargetMarket4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TargetMarket4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RefDt", skip_serializing_if = "Option::is_none") )]
	pub ref_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvstrTp", skip_serializing_if = "Option::is_none") )]
	pub invstr_tp: Option<InvestorType2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "KnwldgAndOrExprnc", skip_serializing_if = "Option::is_none") )]
	pub knwldg_and_or_exprnc: Option<InvestorKnowledge1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AbltyToBearLosses", skip_serializing_if = "Option::is_none") )]
	pub ablty_to_bear_losses: Option<LossBearing2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RskTlrnce", skip_serializing_if = "Option::is_none") )]
	pub rsk_tlrnce: Option<RiskTolerance1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClntObjctvsAndNeeds", skip_serializing_if = "Option::is_none") )]
	pub clnt_objctvs_and_needs: Option<InvestorRequirements4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<Vec<OtherTargetMarket1>>,
}

impl TargetMarket4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.invstr_tp { val.validate()? }
		if let Some(ref val) = self.knwldg_and_or_exprnc { val.validate()? }
		if let Some(ref val) = self.ablty_to_bear_losses { val.validate()? }
		if let Some(ref val) = self.rsk_tlrnce { val.validate()? }
		if let Some(ref val) = self.clnt_objctvs_and_needs { val.validate()? }
		if let Some(ref vec) = self.othr { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TargetMarket5Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TargetMarket5Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<InvestorType4Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<TargetMarket1Code>,
}

impl TargetMarket5Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.othr { val.validate()? }
		Ok(())
	}
}


// Tax17 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Tax17 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<TaxType12Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XtndedTp", skip_serializing_if = "Option::is_none") )]
	pub xtnded_tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<Vec<ActiveOrHistoricCurrencyAnd13DecimalAmount>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rate", skip_serializing_if = "Option::is_none") )]
	pub rate: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctry") )]
	pub ctry: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxClctnDtls", skip_serializing_if = "Option::is_none") )]
	pub tax_clctn_dtls: Option<TaxCalculationInformation4>,
}

impl Tax17 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.xtnded_tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "xtnded_tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "xtnded_tp exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref vec) = self.amt { for item in vec { item.validate()? } }
		let pattern = Regex::new("[A-Z]{2,2}").unwrap();
		if !pattern.is_match(&self.ctry) {
			return Err(ValidationError::new(1005, "ctry does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.tax_clctn_dtls { val.validate()? }
		Ok(())
	}
}


// TaxAmount2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TaxAmount2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rate", skip_serializing_if = "Option::is_none") )]
	pub rate: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxblBaseAmt", skip_serializing_if = "Option::is_none") )]
	pub taxbl_base_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlAmt", skip_serializing_if = "Option::is_none") )]
	pub ttl_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dtls", skip_serializing_if = "Option::is_none") )]
	pub dtls: Option<Vec<TaxRecordDetails2>>,
}

impl TaxAmount2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.taxbl_base_amt { val.validate()? }
		if let Some(ref val) = self.ttl_amt { val.validate()? }
		if let Some(ref vec) = self.dtls { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TaxAmount3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TaxAmount3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rate", skip_serializing_if = "Option::is_none") )]
	pub rate: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxblBaseAmt", skip_serializing_if = "Option::is_none") )]
	pub taxbl_base_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlAmt", skip_serializing_if = "Option::is_none") )]
	pub ttl_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dtls", skip_serializing_if = "Option::is_none") )]
	pub dtls: Option<Vec<TaxRecordDetails3>>,
}

impl TaxAmount3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.taxbl_base_amt { val.validate()? }
		if let Some(ref val) = self.ttl_amt { val.validate()? }
		if let Some(ref vec) = self.dtls { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TaxAmountAndType1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TaxAmountAndType1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<TaxAmountType1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveOrHistoricCurrencyAndAmount,
}

impl TaxAmountAndType1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tp { val.validate()? }
		self.amt.validate()?;
		Ok(())
	}
}


// TaxAmountType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TaxAmountType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl TaxAmountType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// TaxAuthorisation1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TaxAuthorisation1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Titl", skip_serializing_if = "Option::is_none") )]
	pub titl: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<String>,
}

impl TaxAuthorisation1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.titl {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "titl is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "titl exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "nm exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// TaxCalculation1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TaxCalculation1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "HstCcy") )]
	pub hst_ccy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxblSvcChrgConvs") )]
	pub taxbl_svc_chrg_convs: Vec<BillingServicesAmount3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlTaxblSvcChrgHstAmt") )]
	pub ttl_taxbl_svc_chrg_hst_amt: AmountAndDirection34,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxId") )]
	pub tax_id: Vec<BillingServicesTax3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlTax") )]
	pub ttl_tax: AmountAndDirection34,
}

impl TaxCalculation1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.hst_ccy) {
			return Err(ValidationError::new(1005, "hst_ccy does not match the required pattern".to_string()));
		}
		for item in &self.taxbl_svc_chrg_convs { item.validate()? }
		self.ttl_taxbl_svc_chrg_hst_amt.validate()?;
		for item in &self.tax_id { item.validate()? }
		self.ttl_tax.validate()?;
		Ok(())
	}
}


// TaxCalculationInformation4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TaxCalculationInformation4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "EUCptlGn", skip_serializing_if = "Option::is_none") )]
	pub eu_cptl_gn: Option<EUCapitalGain2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XtndedEUCptlGn", skip_serializing_if = "Option::is_none") )]
	pub xtnded_eu_cptl_gn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PctgOfDebtClm", skip_serializing_if = "Option::is_none") )]
	pub pctg_of_debt_clm: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PctgGrdfthdDebt", skip_serializing_if = "Option::is_none") )]
	pub pctg_grdfthd_debt: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxblIncmPerDvdd", skip_serializing_if = "Option::is_none") )]
	pub taxbl_incm_per_dvdd: Option<ActiveOrHistoricCurrencyAnd13DecimalAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EUDvddSts", skip_serializing_if = "Option::is_none") )]
	pub eu_dvdd_sts: Option<EUDividendStatus1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XtndedEUDvddSts", skip_serializing_if = "Option::is_none") )]
	pub xtnded_eu_dvdd_sts: Option<String>,
}

impl TaxCalculationInformation4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.eu_cptl_gn { val.validate()? }
		if let Some(ref val) = self.xtnded_eu_cptl_gn {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "xtnded_eu_cptl_gn is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "xtnded_eu_cptl_gn exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.taxbl_incm_per_dvdd { val.validate()? }
		if let Some(ref val) = self.eu_dvdd_sts { val.validate()? }
		if let Some(ref val) = self.xtnded_eu_dvdd_sts {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "xtnded_eu_dvdd_sts is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "xtnded_eu_dvdd_sts exceeds the maximum length of 350".to_string()));
			}
		}
		Ok(())
	}
}


// TaxCharges2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TaxCharges2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rate", skip_serializing_if = "Option::is_none") )]
	pub rate: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<ActiveOrHistoricCurrencyAndAmount>,
}

impl TaxCharges2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.amt { val.validate()? }
		Ok(())
	}
}


// TaxData1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TaxData1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cdtr", skip_serializing_if = "Option::is_none") )]
	pub cdtr: Option<TaxParty1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dbtr", skip_serializing_if = "Option::is_none") )]
	pub dbtr: Option<TaxParty2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtDbtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_dbtr: Option<TaxParty2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AdmstnZone", skip_serializing_if = "Option::is_none") )]
	pub admstn_zone: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RefNb", skip_serializing_if = "Option::is_none") )]
	pub ref_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mtd", skip_serializing_if = "Option::is_none") )]
	pub mtd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlTaxblBaseAmt", skip_serializing_if = "Option::is_none") )]
	pub ttl_taxbl_base_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlTaxAmt", skip_serializing_if = "Option::is_none") )]
	pub ttl_tax_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dt", skip_serializing_if = "Option::is_none") )]
	pub dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SeqNb", skip_serializing_if = "Option::is_none") )]
	pub seq_nb: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rcrd", skip_serializing_if = "Option::is_none") )]
	pub rcrd: Option<Vec<TaxRecord3>>,
}

impl TaxData1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cdtr { val.validate()? }
		if let Some(ref val) = self.dbtr { val.validate()? }
		if let Some(ref val) = self.ultmt_dbtr { val.validate()? }
		if let Some(ref val) = self.admstn_zone {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "admstn_zone is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "admstn_zone exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.ref_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ref_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "ref_nb exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.mtd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mtd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "mtd exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.ttl_taxbl_base_amt { val.validate()? }
		if let Some(ref val) = self.ttl_tax_amt { val.validate()? }
		if let Some(ref vec) = self.rcrd { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TaxExemptReason1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum TaxExemptReason1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "NONE") )]
	CodeNONE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MASA") )]
	CodeMASA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MISA") )]
	CodeMISA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SISA") )]
	CodeSISA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IISA") )]
	CodeIISA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CUYP") )]
	CodeCUYP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRYP") )]
	CodePRYP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ASTR") )]
	CodeASTR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EMPY") )]
	CodeEMPY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EMCY") )]
	CodeEMCY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EPRY") )]
	CodeEPRY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ECYE") )]
	CodeECYE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NFPI") )]
	CodeNFPI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NFQP") )]
	CodeNFQP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DECP") )]
	CodeDECP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IRAC") )]
	CodeIRAC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IRAR") )]
	CodeIRAR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "KEOG") )]
	CodeKEOG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PFSP") )]
	CodePFSP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "401K") )]
	Code401K,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SIRA") )]
	CodeSIRA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "403B") )]
	Code403B,
	#[cfg_attr( feature = "derive_serde", serde(rename = "457X") )]
	Code457X,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RIRA") )]
	CodeRIRA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RIAN") )]
	CodeRIAN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RCRF") )]
	CodeRCRF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RCIP") )]
	CodeRCIP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EIFP") )]
	CodeEIFP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EIOP") )]
	CodeEIOP,
}

impl TaxExemptReason1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TaxExemptReason3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum TaxExemptReason3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "NONE") )]
	CodeNONE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MASA") )]
	CodeMASA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MISA") )]
	CodeMISA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SISA") )]
	CodeSISA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IISA") )]
	CodeIISA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CUYP") )]
	CodeCUYP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRYP") )]
	CodePRYP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ASTR") )]
	CodeASTR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EMPY") )]
	CodeEMPY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EMCY") )]
	CodeEMCY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EPRY") )]
	CodeEPRY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ECYE") )]
	CodeECYE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NFPI") )]
	CodeNFPI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NFQP") )]
	CodeNFQP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DECP") )]
	CodeDECP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IRAC") )]
	CodeIRAC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IRAR") )]
	CodeIRAR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "KEOG") )]
	CodeKEOG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PFSP") )]
	CodePFSP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "401K") )]
	Code401K,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SIRA") )]
	CodeSIRA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "403B") )]
	Code403B,
	#[cfg_attr( feature = "derive_serde", serde(rename = "457X") )]
	Code457X,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RIRA") )]
	CodeRIRA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RIAN") )]
	CodeRIAN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RCRF") )]
	CodeRCRF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RCIP") )]
	CodeRCIP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EIFP") )]
	CodeEIFP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EIOP") )]
	CodeEIOP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FORE") )]
	CodeFORE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INCA") )]
	CodeINCA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MINO") )]
	CodeMINO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ASSO") )]
	CodeASSO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DIPL") )]
	CodeDIPL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DOME") )]
	CodeDOME,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FORP") )]
	CodeFORP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ORDR") )]
	CodeORDR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PENF") )]
	CodePENF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REFU") )]
	CodeREFU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RIHO") )]
	CodeRIHO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ADMI") )]
	CodeADMI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TANR") )]
	CodeTANR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OANR") )]
	CodeOANR,
}

impl TaxExemptReason3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TaxExemptionReason2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TaxExemptionReason2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<TaxExemptReason3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl TaxExemptionReason2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// TaxExemptionReasonFormat1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TaxExemptionReasonFormat1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ustrd", skip_serializing_if = "Option::is_none") )]
	pub ustrd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Strd", skip_serializing_if = "Option::is_none") )]
	pub strd: Option<TaxExemptReason1Code>,
}

impl TaxExemptionReasonFormat1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ustrd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ustrd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "ustrd exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.strd { val.validate()? }
		Ok(())
	}
}


// TaxInformation7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TaxInformation7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cdtr", skip_serializing_if = "Option::is_none") )]
	pub cdtr: Option<TaxParty1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dbtr", skip_serializing_if = "Option::is_none") )]
	pub dbtr: Option<TaxParty2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtDbtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_dbtr: Option<TaxParty2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AdmstnZone", skip_serializing_if = "Option::is_none") )]
	pub admstn_zone: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RefNb", skip_serializing_if = "Option::is_none") )]
	pub ref_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mtd", skip_serializing_if = "Option::is_none") )]
	pub mtd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlTaxblBaseAmt", skip_serializing_if = "Option::is_none") )]
	pub ttl_taxbl_base_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlTaxAmt", skip_serializing_if = "Option::is_none") )]
	pub ttl_tax_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dt", skip_serializing_if = "Option::is_none") )]
	pub dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SeqNb", skip_serializing_if = "Option::is_none") )]
	pub seq_nb: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rcrd", skip_serializing_if = "Option::is_none") )]
	pub rcrd: Option<Vec<TaxRecord2>>,
}

impl TaxInformation7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cdtr { val.validate()? }
		if let Some(ref val) = self.dbtr { val.validate()? }
		if let Some(ref val) = self.ultmt_dbtr { val.validate()? }
		if let Some(ref val) = self.admstn_zone {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "admstn_zone is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "admstn_zone exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.ref_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ref_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "ref_nb exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.mtd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mtd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "mtd exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.ttl_taxbl_base_amt { val.validate()? }
		if let Some(ref val) = self.ttl_tax_amt { val.validate()? }
		if let Some(ref vec) = self.rcrd { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TaxOrganisationIdentification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TaxOrganisationIdentification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm") )]
	pub nm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstlAdr", skip_serializing_if = "Option::is_none") )]
	pub pstl_adr: Option<PostalAddress6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtctDtls", skip_serializing_if = "Option::is_none") )]
	pub ctct_dtls: Option<ContactDetails2>,
}

impl TaxOrganisationIdentification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "nm is shorter than the minimum length of 1".to_string()));
		}
		if self.nm.chars().count() > 140 {
			return Err(ValidationError::new(1002, "nm exceeds the maximum length of 140".to_string()));
		}
		if let Some(ref val) = self.pstl_adr { val.validate()? }
		if let Some(ref val) = self.ctct_dtls { val.validate()? }
		Ok(())
	}
}


// TaxParty1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TaxParty1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxId", skip_serializing_if = "Option::is_none") )]
	pub tax_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegnId", skip_serializing_if = "Option::is_none") )]
	pub regn_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxTp", skip_serializing_if = "Option::is_none") )]
	pub tax_tp: Option<String>,
}

impl TaxParty1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tax_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tax_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tax_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.regn_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "regn_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "regn_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.tax_tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tax_tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tax_tp exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// TaxParty2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TaxParty2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxId", skip_serializing_if = "Option::is_none") )]
	pub tax_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegnId", skip_serializing_if = "Option::is_none") )]
	pub regn_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxTp", skip_serializing_if = "Option::is_none") )]
	pub tax_tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Authstn", skip_serializing_if = "Option::is_none") )]
	pub authstn: Option<TaxAuthorisation1>,
}

impl TaxParty2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tax_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tax_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tax_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.regn_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "regn_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "regn_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.tax_tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tax_tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tax_tp exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.authstn { val.validate()? }
		Ok(())
	}
}


// TaxParty4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TaxParty4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxId", skip_serializing_if = "Option::is_none") )]
	pub tax_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxTp", skip_serializing_if = "Option::is_none") )]
	pub tax_tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RegnId", skip_serializing_if = "Option::is_none") )]
	pub regn_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxXmptnRsn", skip_serializing_if = "Option::is_none") )]
	pub tax_xmptn_rsn: Option<Vec<TaxExemptionReasonFormat1Choice>>,
}

impl TaxParty4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tax_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tax_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tax_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.tax_tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tax_tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tax_tp exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.regn_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "regn_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "regn_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref vec) = self.tax_xmptn_rsn { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TaxPeriod2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TaxPeriod2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Yr", skip_serializing_if = "Option::is_none") )]
	pub yr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<TaxRecordPeriod1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrToDt", skip_serializing_if = "Option::is_none") )]
	pub fr_to_dt: Option<DatePeriod2>,
}

impl TaxPeriod2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.fr_to_dt { val.validate()? }
		Ok(())
	}
}


// TaxPeriod3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TaxPeriod3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Yr", skip_serializing_if = "Option::is_none") )]
	pub yr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<TaxRecordPeriod1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrToDt", skip_serializing_if = "Option::is_none") )]
	pub fr_to_dt: Option<DatePeriod2>,
}

impl TaxPeriod3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.fr_to_dt { val.validate()? }
		Ok(())
	}
}


// TaxRateMarker1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum TaxRateMarker1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ALPR") )]
	CodeALPR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ALIT") )]
	CodeALIT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GRSS") )]
	CodeGRSS,
}

impl TaxRateMarker1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TaxReason1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TaxReason1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd") )]
	pub cd: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Expltn") )]
	pub expltn: String,
}

impl TaxReason1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.cd.chars().count() < 1 {
			return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
		}
		if self.cd.chars().count() > 10 {
			return Err(ValidationError::new(1002, "cd exceeds the maximum length of 10".to_string()));
		}
		if self.expltn.chars().count() < 1 {
			return Err(ValidationError::new(1001, "expltn is shorter than the minimum length of 1".to_string()));
		}
		if self.expltn.chars().count() > 105 {
			return Err(ValidationError::new(1002, "expltn exceeds the maximum length of 105".to_string()));
		}
		Ok(())
	}
}


// TaxRecord2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TaxRecord2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctgy", skip_serializing_if = "Option::is_none") )]
	pub ctgy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtgyDtls", skip_serializing_if = "Option::is_none") )]
	pub ctgy_dtls: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrSts", skip_serializing_if = "Option::is_none") )]
	pub dbtr_sts: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CertId", skip_serializing_if = "Option::is_none") )]
	pub cert_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrmsCd", skip_serializing_if = "Option::is_none") )]
	pub frms_cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prd", skip_serializing_if = "Option::is_none") )]
	pub prd: Option<TaxPeriod2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxAmt", skip_serializing_if = "Option::is_none") )]
	pub tax_amt: Option<TaxAmount2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
}

impl TaxRecord2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tp exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.ctgy {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ctgy is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "ctgy exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.ctgy_dtls {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ctgy_dtls is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "ctgy_dtls exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.dbtr_sts {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "dbtr_sts is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "dbtr_sts exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.cert_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cert_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "cert_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.frms_cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "frms_cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "frms_cd exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.prd { val.validate()? }
		if let Some(ref val) = self.tax_amt { val.validate()? }
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// TaxRecord3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TaxRecord3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctgy", skip_serializing_if = "Option::is_none") )]
	pub ctgy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtgyDtls", skip_serializing_if = "Option::is_none") )]
	pub ctgy_dtls: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrSts", skip_serializing_if = "Option::is_none") )]
	pub dbtr_sts: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CertId", skip_serializing_if = "Option::is_none") )]
	pub cert_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrmsCd", skip_serializing_if = "Option::is_none") )]
	pub frms_cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prd", skip_serializing_if = "Option::is_none") )]
	pub prd: Option<TaxPeriod3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxAmt", skip_serializing_if = "Option::is_none") )]
	pub tax_amt: Option<TaxAmount3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
}

impl TaxRecord3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tp exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.ctgy {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ctgy is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "ctgy exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.ctgy_dtls {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ctgy_dtls is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "ctgy_dtls exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.dbtr_sts {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "dbtr_sts is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "dbtr_sts exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.cert_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cert_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "cert_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.frms_cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "frms_cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "frms_cd exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.prd { val.validate()? }
		if let Some(ref val) = self.tax_amt { val.validate()? }
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// TaxRecordDetails2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TaxRecordDetails2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prd", skip_serializing_if = "Option::is_none") )]
	pub prd: Option<TaxPeriod2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveOrHistoricCurrencyAndAmount,
}

impl TaxRecordDetails2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.prd { val.validate()? }
		self.amt.validate()?;
		Ok(())
	}
}


// TaxRecordDetails3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TaxRecordDetails3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prd", skip_serializing_if = "Option::is_none") )]
	pub prd: Option<TaxPeriod3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveOrHistoricCurrencyAndAmount,
}

impl TaxRecordDetails3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.prd { val.validate()? }
		self.amt.validate()?;
		Ok(())
	}
}


// TaxRecordPeriod1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum TaxRecordPeriod1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "MM01") )]
	CodeMM01,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MM02") )]
	CodeMM02,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MM03") )]
	CodeMM03,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MM04") )]
	CodeMM04,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MM05") )]
	CodeMM05,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MM06") )]
	CodeMM06,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MM07") )]
	CodeMM07,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MM08") )]
	CodeMM08,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MM09") )]
	CodeMM09,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MM10") )]
	CodeMM10,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MM11") )]
	CodeMM11,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MM12") )]
	CodeMM12,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QTR1") )]
	CodeQTR1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QTR2") )]
	CodeQTR2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QTR3") )]
	CodeQTR3,
	#[cfg_attr( feature = "derive_serde", serde(rename = "QTR4") )]
	CodeQTR4,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HLF1") )]
	CodeHLF1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HLF2") )]
	CodeHLF2,
}

impl TaxRecordPeriod1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TaxReport1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TaxReport1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxRptHdr") )]
	pub tax_rpt_hdr: GroupHeader69,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sellr") )]
	pub sellr: PartyIdentification72,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Buyr", skip_serializing_if = "Option::is_none") )]
	pub buyr: Option<PartyIdentification72>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradSttlm") )]
	pub trad_sttlm: TradeSettlement2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrPty", skip_serializing_if = "Option::is_none") )]
	pub othr_pty: Option<Vec<PartyIdentification72>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<Vec<AdditionalInformation1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlRef", skip_serializing_if = "Option::is_none") )]
	pub addtl_ref: Option<Vec<DocumentGeneralInformation2>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl TaxReport1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tax_rpt_hdr.validate()?;
		self.sellr.validate()?;
		if let Some(ref val) = self.buyr { val.validate()? }
		self.trad_sttlm.validate()?;
		if let Some(ref vec) = self.othr_pty { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.addtl_inf { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.addtl_ref { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TaxReportHeader1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TaxReportHeader1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId") )]
	pub msg_id: MessageIdentification1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfTaxRpts", skip_serializing_if = "Option::is_none") )]
	pub nb_of_tax_rpts: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxAuthrty", skip_serializing_if = "Option::is_none") )]
	pub tax_authrty: Option<Vec<TaxOrganisationIdentification1>>,
}

impl TaxReportHeader1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.msg_id.validate()?;
		if let Some(ref vec) = self.tax_authrty { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TaxReporting3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TaxReporting3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxtnCtry") )]
	pub taxtn_ctry: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxRate", skip_serializing_if = "Option::is_none") )]
	pub tax_rate: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxPyer", skip_serializing_if = "Option::is_none") )]
	pub tax_pyer: Option<PartyIdentification125Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxRcpt", skip_serializing_if = "Option::is_none") )]
	pub tax_rcpt: Option<PartyIdentification125Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshAcctDtls", skip_serializing_if = "Option::is_none") )]
	pub csh_acct_dtls: Option<CashAccount204>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Desc", skip_serializing_if = "Option::is_none") )]
	pub desc: Option<String>,
}

impl TaxReporting3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{2,2}").unwrap();
		if !pattern.is_match(&self.taxtn_ctry) {
			return Err(ValidationError::new(1005, "taxtn_ctry does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.tax_pyer { val.validate()? }
		if let Some(ref val) = self.tax_rcpt { val.validate()? }
		if let Some(ref val) = self.csh_acct_dtls { val.validate()? }
		if let Some(ref val) = self.desc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "desc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "desc exceeds the maximum length of 350".to_string()));
			}
		}
		Ok(())
	}
}


// TaxReportingStatus1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum TaxReportingStatus1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACPT") )]
	CodeACPT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RCVD") )]
	CodeRCVD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RJCT") )]
	CodeRJCT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INCF") )]
	CodeINCF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CRPT") )]
	CodeCRPT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WARN") )]
	CodeWARN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACTC") )]
	CodeACTC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PART") )]
	CodePART,
}

impl TaxReportingStatus1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TaxReportingStatus2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum TaxReportingStatus2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACPT") )]
	CodeACPT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RJCT") )]
	CodeRJCT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WARN") )]
	CodeWARN,
}

impl TaxReportingStatus2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TaxType12Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum TaxType12Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "INPO") )]
	CodeINPO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EUTR") )]
	CodeEUTR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AKT1") )]
	CodeAKT1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AKT2") )]
	CodeAKT2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ZWIS") )]
	CodeZWIS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MIET") )]
	CodeMIET,
}

impl TaxType12Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TaxWithholdingMethod3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum TaxWithholdingMethod3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "MITX") )]
	CodeMITX,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INVE") )]
	CodeINVE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACCT") )]
	CodeACCT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EXMT") )]
	CodeEXMT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REPT") )]
	CodeREPT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CRTF") )]
	CodeCRTF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WHCO") )]
	CodeWHCO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WTHD") )]
	CodeWTHD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WTRE") )]
	CodeWTRE,
}

impl TaxWithholdingMethod3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TaxableIncomePerShareCalculated2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum TaxableIncomePerShareCalculated2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "TSIY") )]
	CodeTSIY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TSIN") )]
	CodeTSIN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UKWN") )]
	CodeUKWN,
}

impl TaxableIncomePerShareCalculated2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TechnicalAttributes5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TechnicalAttributes5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechRcrdId", skip_serializing_if = "Option::is_none") )]
	pub tech_rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RcncltnFlg", skip_serializing_if = "Option::is_none") )]
	pub rcncltn_flg: Option<Reconciliation3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptRctTmStmp", skip_serializing_if = "Option::is_none") )]
	pub rpt_rct_tm_stmp: Option<String>,
}

impl TechnicalAttributes5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tech_rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tech_rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "tech_rcrd_id exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.rcncltn_flg { val.validate()? }
		Ok(())
	}
}


// TechnicalAttributes6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TechnicalAttributes6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechRcrdId", skip_serializing_if = "Option::is_none") )]
	pub tech_rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptRctTmStmp", skip_serializing_if = "Option::is_none") )]
	pub rpt_rct_tm_stmp: Option<String>,
}

impl TechnicalAttributes6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tech_rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tech_rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "tech_rcrd_id exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// TechnicalIdentification2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TechnicalIdentification2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BICFI", skip_serializing_if = "Option::is_none") )]
	pub bicfi: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechAdr", skip_serializing_if = "Option::is_none") )]
	pub tech_adr: Option<String>,
}

impl TechnicalIdentification2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.bicfi {
			let pattern = Regex::new("[A-Z0-9]{4,4}[A-Z]{2,2}[A-Z0-9]{2,2}([A-Z0-9]{3,3}){0,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "bicfi does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.tech_adr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tech_adr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 256 {
				return Err(ValidationError::new(1002, "tech_adr exceeds the maximum length of 256".to_string()));
			}
		}
		Ok(())
	}
}


// TechnicalInputChannel1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TechnicalInputChannel1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl TechnicalInputChannel1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// Term1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Term1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Oprtr") )]
	pub oprtr: Operator1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val") )]
	pub val: RateOrAbsoluteValue1Choice,
}

impl Term1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.oprtr.validate()?;
		self.val.validate()?;
		Ok(())
	}
}


// ThirdPartyRights2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ThirdPartyRights2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtTm", skip_serializing_if = "Option::is_none") )]
	pub dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Hldr", skip_serializing_if = "Option::is_none") )]
	pub hldr: Option<PartyIdentification125Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LglNttyIdr", skip_serializing_if = "Option::is_none") )]
	pub lgl_ntty_idr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Desc", skip_serializing_if = "Option::is_none") )]
	pub desc: Option<String>,
}

impl ThirdPartyRights2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.tp.chars().count() < 1 {
			return Err(ValidationError::new(1001, "tp is shorter than the minimum length of 1".to_string()));
		}
		if self.tp.chars().count() > 35 {
			return Err(ValidationError::new(1002, "tp exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.hldr { val.validate()? }
		if let Some(ref val) = self.lgl_ntty_idr {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "lgl_ntty_idr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.amt { val.validate()? }
		if let Some(ref val) = self.desc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "desc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "desc exceeds the maximum length of 350".to_string()));
			}
		}
		Ok(())
	}
}


// TimeFrame10 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TimeFrame10 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrTmFrameDesc", skip_serializing_if = "Option::is_none") )]
	pub othr_tm_frame_desc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TPlus", skip_serializing_if = "Option::is_none") )]
	pub t_plus: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NonWorkgDayAdjstmnt", skip_serializing_if = "Option::is_none") )]
	pub non_workg_day_adjstmnt: Option<BusinessDayConvention1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RefrToOrdrDsk", skip_serializing_if = "Option::is_none") )]
	pub refr_to_ordr_dsk: Option<ReferToFundOrderDesk1Code>,
}

impl TimeFrame10 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.othr_tm_frame_desc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "othr_tm_frame_desc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "othr_tm_frame_desc exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.non_workg_day_adjstmnt { val.validate()? }
		if let Some(ref val) = self.refr_to_ordr_dsk { val.validate()? }
		Ok(())
	}
}


// TimeFrame11 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TimeFrame11 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrTmFrameDesc", skip_serializing_if = "Option::is_none") )]
	pub othr_tm_frame_desc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TPlus", skip_serializing_if = "Option::is_none") )]
	pub t_plus: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NonWorkgDayAdjstmnt", skip_serializing_if = "Option::is_none") )]
	pub non_workg_day_adjstmnt: Option<BusinessDayConvention1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RefrToOrdrDsk", skip_serializing_if = "Option::is_none") )]
	pub refr_to_ordr_dsk: Option<ReferToFundOrderDesk1Code>,
}

impl TimeFrame11 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.othr_tm_frame_desc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "othr_tm_frame_desc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "othr_tm_frame_desc exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.non_workg_day_adjstmnt { val.validate()? }
		if let Some(ref val) = self.refr_to_ordr_dsk { val.validate()? }
		Ok(())
	}
}


// TimeFrame2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum TimeFrame2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "HOLD") )]
	CodeHOLD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LONG") )]
	CodeLONG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MEDM") )]
	CodeMEDM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SHOR") )]
	CodeSHOR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VSHT") )]
	CodeVSHT,
}

impl TimeFrame2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TimeFrame7Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TimeFrame7Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TPlus", skip_serializing_if = "Option::is_none") )]
	pub t_plus: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prepmt", skip_serializing_if = "Option::is_none") )]
	pub prepmt: Option<bool>,
}

impl TimeFrame7Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TimeFrame8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TimeFrame8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrTmFrameDesc", skip_serializing_if = "Option::is_none") )]
	pub othr_tm_frame_desc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TPlus", skip_serializing_if = "Option::is_none") )]
	pub t_plus: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NonWorkgDayAdjstmnt", skip_serializing_if = "Option::is_none") )]
	pub non_workg_day_adjstmnt: Option<BusinessDayConvention1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RefrToOrdrDsk", skip_serializing_if = "Option::is_none") )]
	pub refr_to_ordr_dsk: Option<ReferToFundOrderDesk1Code>,
}

impl TimeFrame8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.othr_tm_frame_desc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "othr_tm_frame_desc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "othr_tm_frame_desc exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.non_workg_day_adjstmnt { val.validate()? }
		if let Some(ref val) = self.refr_to_ordr_dsk { val.validate()? }
		Ok(())
	}
}


// TimeFrame8Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TimeFrame8Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TPlus", skip_serializing_if = "Option::is_none") )]
	pub t_plus: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RPlus", skip_serializing_if = "Option::is_none") )]
	pub r_plus: Option<f64>,
}

impl TimeFrame8Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TimeFrame9 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TimeFrame9 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrTmFrameDesc", skip_serializing_if = "Option::is_none") )]
	pub othr_tm_frame_desc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TMns", skip_serializing_if = "Option::is_none") )]
	pub t_mns: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NonWorkgDayAdjstmnt", skip_serializing_if = "Option::is_none") )]
	pub non_workg_day_adjstmnt: Option<BusinessDayConvention1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RefrToOrdrDsk", skip_serializing_if = "Option::is_none") )]
	pub refr_to_ordr_dsk: Option<ReferToFundOrderDesk1Code>,
}

impl TimeFrame9 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.othr_tm_frame_desc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "othr_tm_frame_desc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "othr_tm_frame_desc exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.non_workg_day_adjstmnt { val.validate()? }
		if let Some(ref val) = self.refr_to_ordr_dsk { val.validate()? }
		Ok(())
	}
}


// TimeFrame9Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TimeFrame9Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<TimeFrame2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl TimeFrame9Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// TimeHorizon2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TimeHorizon2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfYrs", skip_serializing_if = "Option::is_none") )]
	pub nb_of_yrs: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TmFrame", skip_serializing_if = "Option::is_none") )]
	pub tm_frame: Option<TimeFrame9Choice>,
}

impl TimeHorizon2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tm_frame { val.validate()? }
		Ok(())
	}
}


// TimePeriod1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TimePeriod1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrTm") )]
	pub fr_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ToTm") )]
	pub to_tm: String,
}

impl TimePeriod1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TimePeriod2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TimePeriod2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrTm") )]
	pub fr_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ToTm", skip_serializing_if = "Option::is_none") )]
	pub to_tm: Option<String>,
}

impl TimePeriod2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TimePeriod3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TimePeriod3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrTm", skip_serializing_if = "Option::is_none") )]
	pub fr_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ToTm", skip_serializing_if = "Option::is_none") )]
	pub to_tm: Option<String>,
}

impl TimePeriod3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TimePeriodDetails1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TimePeriodDetails1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrTm") )]
	pub fr_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ToTm", skip_serializing_if = "Option::is_none") )]
	pub to_tm: Option<String>,
}

impl TimePeriodDetails1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TimeToMaturity1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TimeToMaturity1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prd", skip_serializing_if = "Option::is_none") )]
	pub prd: Option<TimeToMaturityPeriod1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Spcl", skip_serializing_if = "Option::is_none") )]
	pub spcl: Option<SpecialPurpose2Code>,
}

impl TimeToMaturity1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.prd { val.validate()? }
		if let Some(ref val) = self.spcl { val.validate()? }
		Ok(())
	}
}


// TimeToMaturity2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TimeToMaturity2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prd", skip_serializing_if = "Option::is_none") )]
	pub prd: Option<TimeToMaturityPeriod2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Spcl", skip_serializing_if = "Option::is_none") )]
	pub spcl: Option<SpecialPurpose2Code>,
}

impl TimeToMaturity2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.prd { val.validate()? }
		if let Some(ref val) = self.spcl { val.validate()? }
		Ok(())
	}
}


// TimeToMaturityPeriod1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TimeToMaturityPeriod1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Start", skip_serializing_if = "Option::is_none") )]
	pub start: Option<MaturityTerm2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "End", skip_serializing_if = "Option::is_none") )]
	pub end: Option<MaturityTerm2>,
}

impl TimeToMaturityPeriod1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.start { val.validate()? }
		if let Some(ref val) = self.end { val.validate()? }
		Ok(())
	}
}


// TimeToMaturityPeriod2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TimeToMaturityPeriod2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Start", skip_serializing_if = "Option::is_none") )]
	pub start: Option<MaturityTerm2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "End", skip_serializing_if = "Option::is_none") )]
	pub end: Option<MaturityTerm2>,
}

impl TimeToMaturityPeriod2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.start { val.validate()? }
		if let Some(ref val) = self.end { val.validate()? }
		Ok(())
	}
}


// TimeUnit1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum TimeUnit1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "DAYC") )]
	CodeDAYC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HOUR") )]
	CodeHOUR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MINU") )]
	CodeMINU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MNTH") )]
	CodeMNTH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SECO") )]
	CodeSECO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WEEK") )]
	CodeWEEK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "YEAR") )]
	CodeYEAR,
}

impl TimeUnit1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TimeUnit3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TimeUnit3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<TimeUnit1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl TimeUnit3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// TonsOrCurrency2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TonsOrCurrency2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nb", skip_serializing_if = "Option::is_none") )]
	pub nb: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<ActiveOrHistoricCurrencyAndAmount>,
}

impl TonsOrCurrency2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.amt { val.validate()? }
		Ok(())
	}
}


// TotalAmountAndCurrency1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TotalAmountAndCurrency1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlAmt") )]
	pub ttl_amt: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbtInd", skip_serializing_if = "Option::is_none") )]
	pub cdt_dbt_ind: Option<CreditDebitCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ccy", skip_serializing_if = "Option::is_none") )]
	pub ccy: Option<String>,
}

impl TotalAmountAndCurrency1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cdt_dbt_ind { val.validate()? }
		if let Some(ref val) = self.ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ccy does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// TotalCharges7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TotalCharges7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfChrgsRcrds") )]
	pub nb_of_chrgs_rcrds: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrlSum", skip_serializing_if = "Option::is_none") )]
	pub ctrl_sum: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlChrgsAmt", skip_serializing_if = "Option::is_none") )]
	pub ttl_chrgs_amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbtInd", skip_serializing_if = "Option::is_none") )]
	pub cdt_dbt_ind: Option<CreditDebitCode>,
}

impl TotalCharges7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[0-9]{1,15}").unwrap();
		if !pattern.is_match(&self.nb_of_chrgs_rcrds) {
			return Err(ValidationError::new(1005, "nb_of_chrgs_rcrds does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.ttl_chrgs_amt { val.validate()? }
		if let Some(ref val) = self.cdt_dbt_ind { val.validate()? }
		Ok(())
	}
}


// TotalCharges8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TotalCharges8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfChrgsBrkdwnItms") )]
	pub nb_of_chrgs_brkdwn_itms: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrlSum", skip_serializing_if = "Option::is_none") )]
	pub ctrl_sum: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlChrgsAmt", skip_serializing_if = "Option::is_none") )]
	pub ttl_chrgs_amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbtInd", skip_serializing_if = "Option::is_none") )]
	pub cdt_dbt_ind: Option<CreditDebitCode>,
}

impl TotalCharges8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[0-9]{1,15}").unwrap();
		if !pattern.is_match(&self.nb_of_chrgs_brkdwn_itms) {
			return Err(ValidationError::new(1005, "nb_of_chrgs_brkdwn_itms does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.ttl_chrgs_amt { val.validate()? }
		if let Some(ref val) = self.cdt_dbt_ind { val.validate()? }
		Ok(())
	}
}


// TotalNumber1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TotalNumber1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CurInstrNb") )]
	pub cur_instr_nb: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlOfLkdInstrs") )]
	pub ttl_of_lkd_instrs: String,
}

impl TotalNumber1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[0-9]{3}").unwrap();
		if !pattern.is_match(&self.cur_instr_nb) {
			return Err(ValidationError::new(1005, "cur_instr_nb does not match the required pattern".to_string()));
		}
		let pattern = Regex::new("[0-9]{3}").unwrap();
		if !pattern.is_match(&self.ttl_of_lkd_instrs) {
			return Err(ValidationError::new(1005, "ttl_of_lkd_instrs does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// TotalTransactions6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TotalTransactions6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNtries", skip_serializing_if = "Option::is_none") )]
	pub ttl_ntries: Option<NumberAndSumOfTransactions4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlCdtNtries", skip_serializing_if = "Option::is_none") )]
	pub ttl_cdt_ntries: Option<NumberAndSumOfTransactions1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlDbtNtries", skip_serializing_if = "Option::is_none") )]
	pub ttl_dbt_ntries: Option<NumberAndSumOfTransactions1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNtriesPerBkTxCd", skip_serializing_if = "Option::is_none") )]
	pub ttl_ntries_per_bk_tx_cd: Option<Vec<TotalsPerBankTransactionCode5>>,
}

impl TotalTransactions6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ttl_ntries { val.validate()? }
		if let Some(ref val) = self.ttl_cdt_ntries { val.validate()? }
		if let Some(ref val) = self.ttl_dbt_ntries { val.validate()? }
		if let Some(ref vec) = self.ttl_ntries_per_bk_tx_cd { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TotalsPerBankTransactionCode5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TotalsPerBankTransactionCode5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfNtries", skip_serializing_if = "Option::is_none") )]
	pub nb_of_ntries: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sum", skip_serializing_if = "Option::is_none") )]
	pub sum: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNetNtry", skip_serializing_if = "Option::is_none") )]
	pub ttl_net_ntry: Option<AmountAndDirection35>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtNtries", skip_serializing_if = "Option::is_none") )]
	pub cdt_ntries: Option<NumberAndSumOfTransactions1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtNtries", skip_serializing_if = "Option::is_none") )]
	pub dbt_ntries: Option<NumberAndSumOfTransactions1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FcstInd", skip_serializing_if = "Option::is_none") )]
	pub fcst_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BkTxCd") )]
	pub bk_tx_cd: BankTransactionCodeStructure4,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Avlbty", skip_serializing_if = "Option::is_none") )]
	pub avlbty: Option<Vec<CashAvailability1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dt", skip_serializing_if = "Option::is_none") )]
	pub dt: Option<DateAndDateTime2Choice>,
}

impl TotalsPerBankTransactionCode5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nb_of_ntries {
			let pattern = Regex::new("[0-9]{1,15}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "nb_of_ntries does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.ttl_net_ntry { val.validate()? }
		if let Some(ref val) = self.cdt_ntries { val.validate()? }
		if let Some(ref val) = self.dbt_ntries { val.validate()? }
		self.bk_tx_cd.validate()?;
		if let Some(ref vec) = self.avlbty { for item in vec { item.validate()? } }
		if let Some(ref val) = self.dt { val.validate()? }
		Ok(())
	}
}


// TrackData1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TrackData1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrckNb", skip_serializing_if = "Option::is_none") )]
	pub trck_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrckVal") )]
	pub trck_val: String,
}

impl TrackData1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.trck_nb {
			let pattern = Regex::new("[0-9]").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "trck_nb does not match the required pattern".to_string()));
			}
		}
		if self.trck_val.chars().count() < 1 {
			return Err(ValidationError::new(1001, "trck_val is shorter than the minimum length of 1".to_string()));
		}
		if self.trck_val.chars().count() > 140 {
			return Err(ValidationError::new(1002, "trck_val exceeds the maximum length of 140".to_string()));
		}
		Ok(())
	}
}


// TrackerData7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TrackerData7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ConfdDt") )]
	pub confd_dt: DateAndDateTime2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ConfdAmt") )]
	pub confd_amt: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrckrRcrd") )]
	pub trckr_rcrd: Vec<TrackerRecord5>,
}

impl TrackerData7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.confd_dt.validate()?;
		self.confd_amt.validate()?;
		for item in &self.trckr_rcrd { item.validate()? }
		Ok(())
	}
}


// TrackerRecord5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TrackerRecord5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Agt") )]
	pub agt: BranchAndFinancialInstitutionIdentification8,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgBr", skip_serializing_if = "Option::is_none") )]
	pub chrg_br: Option<ChargeBearerType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgsAmt", skip_serializing_if = "Option::is_none") )]
	pub chrgs_amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XchgRateData", skip_serializing_if = "Option::is_none") )]
	pub xchg_rate_data: Option<CurrencyExchange13>,
}

impl TrackerRecord5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.agt.validate()?;
		if let Some(ref val) = self.chrg_br { val.validate()? }
		if let Some(ref val) = self.chrgs_amt { val.validate()? }
		if let Some(ref val) = self.xchg_rate_data { val.validate()? }
		Ok(())
	}
}


// TradeAdditionalQueryCriteria7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeAdditionalQueryCriteria7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ActnTp", skip_serializing_if = "Option::is_none") )]
	pub actn_tp: Option<Vec<TransactionOperationType6Code>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExctnVn", skip_serializing_if = "Option::is_none") )]
	pub exctn_vn: Option<SecuritiesTradeVenueCriteria1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtrOfCtrPty", skip_serializing_if = "Option::is_none") )]
	pub ntr_of_ctr_pty: Option<Vec<PartyNatureType1Code>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CorpSctr", skip_serializing_if = "Option::is_none") )]
	pub corp_sctr: Option<Vec<CorporateSectorCriteria5>>,
}

impl TradeAdditionalQueryCriteria7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.actn_tp { for item in vec { item.validate()? } }
		if let Some(ref val) = self.exctn_vn { val.validate()? }
		if let Some(ref vec) = self.ntr_of_ctr_pty { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.corp_sctr { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TradeAdditionalQueryCriteria9 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeAdditionalQueryCriteria9 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ActnTp", skip_serializing_if = "Option::is_none") )]
	pub actn_tp: Option<Vec<TransactionOperationType8Code>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExctnVn", skip_serializing_if = "Option::is_none") )]
	pub exctn_vn: Option<SecuritiesTradeVenueCriteria1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtrOfCtrPty", skip_serializing_if = "Option::is_none") )]
	pub ntr_of_ctr_pty: Option<PartyNatureType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CorpSctr", skip_serializing_if = "Option::is_none") )]
	pub corp_sctr: Option<CorporateSectorCriteria6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AsstClss", skip_serializing_if = "Option::is_none") )]
	pub asst_clss: Option<Vec<ProductType4Code>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PdctClssfctn", skip_serializing_if = "Option::is_none") )]
	pub pdct_clssfctn: Option<ProductClassificationCriteria1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Lvl", skip_serializing_if = "Option::is_none") )]
	pub lvl: Option<ModificationLevel1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EvtTp", skip_serializing_if = "Option::is_none") )]
	pub evt_tp: Option<Vec<DerivativeEventType3Code>>,
}

impl TradeAdditionalQueryCriteria9 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.actn_tp { for item in vec { item.validate()? } }
		if let Some(ref val) = self.exctn_vn { val.validate()? }
		if let Some(ref val) = self.ntr_of_ctr_pty { val.validate()? }
		if let Some(ref val) = self.corp_sctr { val.validate()? }
		if let Some(ref vec) = self.asst_clss { for item in vec { item.validate()? } }
		if let Some(ref val) = self.pdct_clssfctn { val.validate()? }
		if let Some(ref val) = self.lvl { val.validate()? }
		if let Some(ref vec) = self.evt_tp { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TradeClearing11 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeClearing11 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrOblgtn", skip_serializing_if = "Option::is_none") )]
	pub clr_oblgtn: Option<ClearingObligationType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrSts", skip_serializing_if = "Option::is_none") )]
	pub clr_sts: Option<Cleared23Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntraGrp", skip_serializing_if = "Option::is_none") )]
	pub intra_grp: Option<bool>,
}

impl TradeClearing11 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.clr_oblgtn { val.validate()? }
		if let Some(ref val) = self.clr_sts { val.validate()? }
		Ok(())
	}
}


// TradeConfirmation3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeConfirmation3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Confd", skip_serializing_if = "Option::is_none") )]
	pub confd: Option<TradeConfirmation4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NonConfd", skip_serializing_if = "Option::is_none") )]
	pub non_confd: Option<TradeNonConfirmation1>,
}

impl TradeConfirmation3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.confd { val.validate()? }
		if let Some(ref val) = self.non_confd { val.validate()? }
		Ok(())
	}
}


// TradeConfirmation4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeConfirmation4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<TradeConfirmationType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TmStmp", skip_serializing_if = "Option::is_none") )]
	pub tm_stmp: Option<String>,
}

impl TradeConfirmation4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tp { val.validate()? }
		Ok(())
	}
}


// TradeConfirmation4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeConfirmation4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Confd", skip_serializing_if = "Option::is_none") )]
	pub confd: Option<TradeConfirmation5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NonConfd", skip_serializing_if = "Option::is_none") )]
	pub non_confd: Option<TradeNonConfirmation1>,
}

impl TradeConfirmation4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.confd { val.validate()? }
		if let Some(ref val) = self.non_confd { val.validate()? }
		Ok(())
	}
}


// TradeConfirmation5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeConfirmation5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: TradeConfirmationType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TmStmp", skip_serializing_if = "Option::is_none") )]
	pub tm_stmp: Option<String>,
}

impl TradeConfirmation5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tp.validate()?;
		Ok(())
	}
}


// TradeConfirmationType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum TradeConfirmationType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ECNF") )]
	CodeECNF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "YCNF") )]
	CodeYCNF,
}

impl TradeConfirmationType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TradeConfirmationType2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum TradeConfirmationType2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "NCNF") )]
	CodeNCNF,
}

impl TradeConfirmationType2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TradeContract4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeContract4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctDocId", skip_serializing_if = "Option::is_none") )]
	pub ctrct_doc_id: Option<DocumentIdentification22>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradTpId", skip_serializing_if = "Option::is_none") )]
	pub trad_tp_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Buyr") )]
	pub buyr: Vec<TradeParty6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sellr") )]
	pub sellr: Vec<TradeParty6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MtrtyDt", skip_serializing_if = "Option::is_none") )]
	pub mtrty_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrlngtnFlg", skip_serializing_if = "Option::is_none") )]
	pub prlngtn_flg: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StartDt", skip_serializing_if = "Option::is_none") )]
	pub start_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmCcy", skip_serializing_if = "Option::is_none") )]
	pub sttlm_ccy: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XchgRateInf", skip_serializing_if = "Option::is_none") )]
	pub xchg_rate_inf: Option<ExchangeRate1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtSchdl", skip_serializing_if = "Option::is_none") )]
	pub pmt_schdl: Option<InterestPaymentDateRange1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ShipmntSchdl", skip_serializing_if = "Option::is_none") )]
	pub shipmnt_schdl: Option<ShipmentSchedule2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Attchmnt", skip_serializing_if = "Option::is_none") )]
	pub attchmnt: Option<Vec<DocumentGeneralInformation5>>,
}

impl TradeContract4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ctrct_doc_id { val.validate()? }
		if let Some(ref val) = self.trad_tp_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "trad_tp_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "trad_tp_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.amt { val.validate()? }
		for item in &self.buyr { item.validate()? }
		for item in &self.sellr { item.validate()? }
		if let Some(ref val) = self.sttlm_ccy {
			let pattern = Regex::new("[A-Z]{3,3}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "sttlm_ccy does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.xchg_rate_inf { val.validate()? }
		if let Some(ref val) = self.pmt_schdl { val.validate()? }
		if let Some(ref val) = self.shipmnt_schdl { val.validate()? }
		if let Some(ref vec) = self.attchmnt { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TradeCounterpartyRelationship1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeCounterpartyRelationship1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl TradeCounterpartyRelationship1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 100 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 100".to_string()));
			}
		}
		Ok(())
	}
}


// TradeCounterpartyRelationshipRecord1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeCounterpartyRelationshipRecord1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "StartRltshPty") )]
	pub start_rltsh_pty: TradeCounterpartyType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndRltshPty") )]
	pub end_rltsh_pty: TradeCounterpartyType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltshTp") )]
	pub rltsh_tp: TradeCounterpartyRelationship1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Desc", skip_serializing_if = "Option::is_none") )]
	pub desc: Option<String>,
}

impl TradeCounterpartyRelationshipRecord1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.start_rltsh_pty.validate()?;
		self.end_rltsh_pty.validate()?;
		self.rltsh_tp.validate()?;
		if let Some(ref val) = self.desc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "desc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 1000 {
				return Err(ValidationError::new(1002, "desc exceeds the maximum length of 1000".to_string()));
			}
		}
		Ok(())
	}
}


// TradeCounterpartyReport20 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeCounterpartyReport20 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgCtrPty") )]
	pub rptg_ctr_pty: Counterparty45,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrCtrPty") )]
	pub othr_ctr_pty: Counterparty46,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Brkr", skip_serializing_if = "Option::is_none") )]
	pub brkr: Option<OrganisationIdentification15Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubmitgAgt", skip_serializing_if = "Option::is_none") )]
	pub submitg_agt: Option<OrganisationIdentification15Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrMmb", skip_serializing_if = "Option::is_none") )]
	pub clr_mmb: Option<PartyIdentification248Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Bnfcry", skip_serializing_if = "Option::is_none") )]
	pub bnfcry: Option<Vec<PartyIdentification248Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NttyRspnsblForRpt", skip_serializing_if = "Option::is_none") )]
	pub ntty_rspnsbl_for_rpt: Option<OrganisationIdentification15Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExctnAgt", skip_serializing_if = "Option::is_none") )]
	pub exctn_agt: Option<Vec<OrganisationIdentification15Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltshRcrd", skip_serializing_if = "Option::is_none") )]
	pub rltsh_rcrd: Option<Vec<TradeCounterpartyRelationshipRecord1>>,
}

impl TradeCounterpartyReport20 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.rptg_ctr_pty.validate()?;
		self.othr_ctr_pty.validate()?;
		if let Some(ref val) = self.brkr { val.validate()? }
		if let Some(ref val) = self.submitg_agt { val.validate()? }
		if let Some(ref val) = self.clr_mmb { val.validate()? }
		if let Some(ref vec) = self.bnfcry { for item in vec { item.validate()? } }
		if let Some(ref val) = self.ntty_rspnsbl_for_rpt { val.validate()? }
		if let Some(ref vec) = self.exctn_agt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.rltsh_rcrd { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TradeCounterpartyType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum TradeCounterpartyType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "BENE") )]
	CodeBENE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BROK") )]
	CodeBROK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CLEM") )]
	CodeCLEM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EXEA") )]
	CodeEXEA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHC") )]
	CodeOTHC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REPC") )]
	CodeREPC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SBMA") )]
	CodeSBMA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ERFR") )]
	CodeERFR,
}

impl TradeCounterpartyType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TradeData28 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeData28 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PairgRcncltnSts", skip_serializing_if = "Option::is_none") )]
	pub pairg_rcncltn_sts: Option<Vec<NumberOfReportsPerStatus4>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RcncltnRpt") )]
	pub rcncltn_rpt: Vec<ReconciliationReport8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl TradeData28 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.pairg_rcncltn_sts { for item in vec { item.validate()? } }
		for item in &self.rcncltn_rpt { item.validate()? }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TradeData29 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeData29 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptSttstcs") )]
	pub rpt_sttstcs: Vec<DetailedReportStatistics5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxSttstcs") )]
	pub tx_sttstcs: Vec<DetailedTransactionStatistics2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl TradeData29 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		for item in &self.rpt_sttstcs { item.validate()? }
		for item in &self.tx_sttstcs { item.validate()? }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TradeData34Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeData34Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DataSetActn", skip_serializing_if = "Option::is_none") )]
	pub data_set_actn: Option<ReportPeriodActivity1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rpt", skip_serializing_if = "Option::is_none") )]
	pub rpt: Option<Vec<TradeData28>>,
}

impl TradeData34Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.data_set_actn { val.validate()? }
		if let Some(ref vec) = self.rpt { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TradeData35Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeData35Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DataSetActn", skip_serializing_if = "Option::is_none") )]
	pub data_set_actn: Option<ReportPeriodActivity1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rpt", skip_serializing_if = "Option::is_none") )]
	pub rpt: Option<Vec<TradeData29>>,
}

impl TradeData35Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.data_set_actn { val.validate()? }
		if let Some(ref vec) = self.rpt { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TradeData36Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeData36Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DataSetActn", skip_serializing_if = "Option::is_none") )]
	pub data_set_actn: Option<ReportPeriodActivity1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rpt", skip_serializing_if = "Option::is_none") )]
	pub rpt: Option<Vec<ReuseDataReport6Choice>>,
}

impl TradeData36Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.data_set_actn { val.validate()? }
		if let Some(ref vec) = self.rpt { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TradeData37Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeData37Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DataSetActn", skip_serializing_if = "Option::is_none") )]
	pub data_set_actn: Option<ReportPeriodActivity1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Stat", skip_serializing_if = "Option::is_none") )]
	pub stat: Option<Vec<ReuseDataReportCorrection15>>,
}

impl TradeData37Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.data_set_actn { val.validate()? }
		if let Some(ref vec) = self.stat { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TradeData38Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeData38Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DataSetActn", skip_serializing_if = "Option::is_none") )]
	pub data_set_actn: Option<ReportPeriodActivity1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Stat", skip_serializing_if = "Option::is_none") )]
	pub stat: Option<Vec<CollateralMarginNew10>>,
}

impl TradeData38Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.data_set_actn { val.validate()? }
		if let Some(ref vec) = self.stat { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TradeData39Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeData39Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DataSetActn", skip_serializing_if = "Option::is_none") )]
	pub data_set_actn: Option<ReportPeriodActivity1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rpt", skip_serializing_if = "Option::is_none") )]
	pub rpt: Option<Vec<TradeReport21Choice>>,
}

impl TradeData39Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.data_set_actn { val.validate()? }
		if let Some(ref vec) = self.rpt { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TradeData40Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeData40Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DataSetActn", skip_serializing_if = "Option::is_none") )]
	pub data_set_actn: Option<ReportPeriodActivity1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rpt", skip_serializing_if = "Option::is_none") )]
	pub rpt: Option<Vec<TradeReport22Choice>>,
}

impl TradeData40Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.data_set_actn { val.validate()? }
		if let Some(ref vec) = self.rpt { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TradeData43 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeData43 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtySpcfcData") )]
	pub ctr_pty_spcfc_data: Vec<CounterpartySpecificData36>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CmonTradData") )]
	pub cmon_trad_data: CommonTradeDataReport71,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Lvl", skip_serializing_if = "Option::is_none") )]
	pub lvl: Option<ModificationLevel1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechAttrbts", skip_serializing_if = "Option::is_none") )]
	pub tech_attrbts: Option<TechnicalAttributes5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PblcDssmntnData", skip_serializing_if = "Option::is_none") )]
	pub pblc_dssmntn_data: Option<DisseminationData1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl TradeData43 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		for item in &self.ctr_pty_spcfc_data { item.validate()? }
		self.cmon_trad_data.validate()?;
		if let Some(ref val) = self.lvl { val.validate()? }
		if let Some(ref val) = self.tech_attrbts { val.validate()? }
		if let Some(ref val) = self.pblc_dssmntn_data { val.validate()? }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TradeData59Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeData59Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DataSetActn", skip_serializing_if = "Option::is_none") )]
	pub data_set_actn: Option<ReportPeriodActivity1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rpt", skip_serializing_if = "Option::is_none") )]
	pub rpt: Option<Vec<TradeReport33Choice>>,
}

impl TradeData59Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.data_set_actn { val.validate()? }
		if let Some(ref vec) = self.rpt { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TradeData60Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeData60Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DataSetActn", skip_serializing_if = "Option::is_none") )]
	pub data_set_actn: Option<ReportPeriodActivity1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Stat", skip_serializing_if = "Option::is_none") )]
	pub stat: Option<Vec<TradeStateReport23>>,
}

impl TradeData60Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.data_set_actn { val.validate()? }
		if let Some(ref vec) = self.stat { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TradeData61Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeData61Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DataSetActn", skip_serializing_if = "Option::is_none") )]
	pub data_set_actn: Option<ReportPeriodActivity1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rpt", skip_serializing_if = "Option::is_none") )]
	pub rpt: Option<Vec<TradeReport34Choice>>,
}

impl TradeData61Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.data_set_actn { val.validate()? }
		if let Some(ref vec) = self.rpt { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TradeData62Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeData62Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DataSetActn", skip_serializing_if = "Option::is_none") )]
	pub data_set_actn: Option<ReportPeriodActivity1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Stat", skip_serializing_if = "Option::is_none") )]
	pub stat: Option<Vec<MarginReportData10>>,
}

impl TradeData62Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.data_set_actn { val.validate()? }
		if let Some(ref vec) = self.stat { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TradeDateTimeQueryCriteria2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeDateTimeQueryCriteria2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgDtTm", skip_serializing_if = "Option::is_none") )]
	pub rptg_dt_tm: Option<DateTimePeriod1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExctnDtTm", skip_serializing_if = "Option::is_none") )]
	pub exctn_dt_tm: Option<DateTimePeriod1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MtrtyDt", skip_serializing_if = "Option::is_none") )]
	pub mtrty_dt: Option<DateOrBlankQuery2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TermntnDt", skip_serializing_if = "Option::is_none") )]
	pub termntn_dt: Option<DateOrBlankQuery2Choice>,
}

impl TradeDateTimeQueryCriteria2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rptg_dt_tm { val.validate()? }
		if let Some(ref val) = self.exctn_dt_tm { val.validate()? }
		if let Some(ref val) = self.mtrty_dt { val.validate()? }
		if let Some(ref val) = self.termntn_dt { val.validate()? }
		Ok(())
	}
}


// TradeDateTimeQueryCriteria6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeDateTimeQueryCriteria6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgDtTm", skip_serializing_if = "Option::is_none") )]
	pub rptg_dt_tm: Option<DateTimePeriod1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExctnDtTm", skip_serializing_if = "Option::is_none") )]
	pub exctn_dt_tm: Option<DateTimePeriod1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MtrtyDt", skip_serializing_if = "Option::is_none") )]
	pub mtrty_dt: Option<DateOrBlankQuery2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FctvDt", skip_serializing_if = "Option::is_none") )]
	pub fctv_dt: Option<DatePeriod1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValtnDtTm", skip_serializing_if = "Option::is_none") )]
	pub valtn_dt_tm: Option<DateTimePeriod1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XprtnDt", skip_serializing_if = "Option::is_none") )]
	pub xprtn_dt: Option<DateOrBlankQuery2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EarlyTermntnDt", skip_serializing_if = "Option::is_none") )]
	pub early_termntn_dt: Option<DatePeriod1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollTmStmp", skip_serializing_if = "Option::is_none") )]
	pub coll_tm_stmp: Option<DateTimeOrBlankQuery1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HstrclAsOfDt", skip_serializing_if = "Option::is_none") )]
	pub hstrcl_as_of_dt: Option<String>,
}

impl TradeDateTimeQueryCriteria6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rptg_dt_tm { val.validate()? }
		if let Some(ref val) = self.exctn_dt_tm { val.validate()? }
		if let Some(ref val) = self.mtrty_dt { val.validate()? }
		if let Some(ref val) = self.fctv_dt { val.validate()? }
		if let Some(ref val) = self.valtn_dt_tm { val.validate()? }
		if let Some(ref val) = self.xprtn_dt { val.validate()? }
		if let Some(ref val) = self.early_termntn_dt { val.validate()? }
		if let Some(ref val) = self.coll_tm_stmp { val.validate()? }
		Ok(())
	}
}


// TradeError9 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeError9 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechRcrdId", skip_serializing_if = "Option::is_none") )]
	pub tech_rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtySpcfcData") )]
	pub ctr_pty_spcfc_data: CounterpartyData88,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LnData") )]
	pub ln_data: LoanData86,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl TradeError9 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tech_rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tech_rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "tech_rcrd_id exceeds the maximum length of 140".to_string()));
			}
		}
		self.ctr_pty_spcfc_data.validate()?;
		self.ln_data.validate()?;
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TradeMarket2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum TradeMarket2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "DMST") )]
	CodeDMST,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FRGN") )]
	CodeFRGN,
}

impl TradeMarket2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TradeNewTransaction13 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeNewTransaction13 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechRcrdId", skip_serializing_if = "Option::is_none") )]
	pub tech_rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtySpcfcData") )]
	pub ctr_pty_spcfc_data: CounterpartyData88,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LnData") )]
	pub ln_data: TransactionLoanData30Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollData", skip_serializing_if = "Option::is_none") )]
	pub coll_data: Option<TransactionCollateralData18Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LvlTp") )]
	pub lvl_tp: ModificationLevel1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl TradeNewTransaction13 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tech_rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tech_rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "tech_rcrd_id exceeds the maximum length of 140".to_string()));
			}
		}
		self.ctr_pty_spcfc_data.validate()?;
		self.ln_data.validate()?;
		if let Some(ref val) = self.coll_data { val.validate()? }
		self.lvl_tp.validate()?;
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TradeNonConfirmation1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeNonConfirmation1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: TradeConfirmationType2Code,
}

impl TradeNonConfirmation1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tp.validate()?;
		Ok(())
	}
}


// TradeParty6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeParty6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PtyId") )]
	pub pty_id: PartyIdentification272,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LglOrg", skip_serializing_if = "Option::is_none") )]
	pub lgl_org: Option<LegalOrganisation2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxPty", skip_serializing_if = "Option::is_none") )]
	pub tax_pty: Option<Vec<TaxParty4>>,
}

impl TradeParty6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pty_id.validate()?;
		if let Some(ref val) = self.lgl_org { val.validate()? }
		if let Some(ref vec) = self.tax_pty { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TradePartyIdentificationQuery10Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradePartyIdentificationQuery10Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<Vec<PartyIdentification248Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NotRptd", skip_serializing_if = "Option::is_none") )]
	pub not_rptd: Option<NotReported1Code>,
}

impl TradePartyIdentificationQuery10Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.id { for item in vec { item.validate()? } }
		if let Some(ref val) = self.not_rptd { val.validate()? }
		Ok(())
	}
}


// TradePartyIdentificationQuery11Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradePartyIdentificationQuery11Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<Vec<OrganisationIdentification15Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NotRptd", skip_serializing_if = "Option::is_none") )]
	pub not_rptd: Option<NotReported1Code>,
}

impl TradePartyIdentificationQuery11Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.id { for item in vec { item.validate()? } }
		if let Some(ref val) = self.not_rptd { val.validate()? }
		Ok(())
	}
}


// TradePartyIdentificationQuery8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradePartyIdentificationQuery8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "LEI", skip_serializing_if = "Option::is_none") )]
	pub lei: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AnyBIC", skip_serializing_if = "Option::is_none") )]
	pub any_bic: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClntId", skip_serializing_if = "Option::is_none") )]
	pub clnt_id: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NotRptd", skip_serializing_if = "Option::is_none") )]
	pub not_rptd: Option<NotReported1Code>,
}

impl TradePartyIdentificationQuery8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.lei {
			for item in vec {
				let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
				if !pattern.is_match(&item) {
					return Err(ValidationError::new(1005, "lei does not match the required pattern".to_string()));
				}
			}
		}
		if let Some(ref vec) = self.any_bic {
			for item in vec {
				let pattern = Regex::new("[A-Z0-9]{4,4}[A-Z]{2,2}[A-Z0-9]{2,2}([A-Z0-9]{3,3}){0,1}").unwrap();
				if !pattern.is_match(&item) {
					return Err(ValidationError::new(1005, "any_bic does not match the required pattern".to_string()));
				}
			}
		}
		if let Some(ref vec) = self.clnt_id {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "clnt_id is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 50 {
					return Err(ValidationError::new(1002, "clnt_id exceeds the maximum length of 50".to_string()));
				}
			}
		}
		if let Some(ref val) = self.not_rptd { val.validate()? }
		Ok(())
	}
}


// TradePartyIdentificationQuery9 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradePartyIdentificationQuery9 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "LEI", skip_serializing_if = "Option::is_none") )]
	pub lei: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtryCd", skip_serializing_if = "Option::is_none") )]
	pub ctry_cd: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AnyBIC", skip_serializing_if = "Option::is_none") )]
	pub any_bic: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClntId", skip_serializing_if = "Option::is_none") )]
	pub clnt_id: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NotRptd", skip_serializing_if = "Option::is_none") )]
	pub not_rptd: Option<NotReported1Code>,
}

impl TradePartyIdentificationQuery9 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.lei {
			for item in vec {
				let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
				if !pattern.is_match(&item) {
					return Err(ValidationError::new(1005, "lei does not match the required pattern".to_string()));
				}
			}
		}
		if let Some(ref vec) = self.ctry_cd {
			for item in vec {
				let pattern = Regex::new("[A-Z]{2,2}").unwrap();
				if !pattern.is_match(&item) {
					return Err(ValidationError::new(1005, "ctry_cd does not match the required pattern".to_string()));
				}
			}
		}
		if let Some(ref vec) = self.any_bic {
			for item in vec {
				let pattern = Regex::new("[A-Z0-9]{4,4}[A-Z]{2,2}[A-Z0-9]{2,2}([A-Z0-9]{3,3}){0,1}").unwrap();
				if !pattern.is_match(&item) {
					return Err(ValidationError::new(1005, "any_bic does not match the required pattern".to_string()));
				}
			}
		}
		if let Some(ref vec) = self.clnt_id {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "clnt_id is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 50 {
					return Err(ValidationError::new(1002, "clnt_id exceeds the maximum length of 50".to_string()));
				}
			}
		}
		if let Some(ref val) = self.not_rptd { val.validate()? }
		Ok(())
	}
}


// TradePartyQueryCriteria5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradePartyQueryCriteria5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Oprtr") )]
	pub oprtr: Operation3Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgCtrPty", skip_serializing_if = "Option::is_none") )]
	pub rptg_ctr_pty: Option<TradePartyIdentificationQuery8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgCtrPtyBrnch", skip_serializing_if = "Option::is_none") )]
	pub rptg_ctr_pty_brnch: Option<TradePartyIdentificationQuery9>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrCtrPty", skip_serializing_if = "Option::is_none") )]
	pub othr_ctr_pty: Option<TradePartyIdentificationQuery8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrCtrPtyBrnch", skip_serializing_if = "Option::is_none") )]
	pub othr_ctr_pty_brnch: Option<TradePartyIdentificationQuery9>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Bnfcry", skip_serializing_if = "Option::is_none") )]
	pub bnfcry: Option<TradePartyIdentificationQuery8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubmitgAgt", skip_serializing_if = "Option::is_none") )]
	pub submitg_agt: Option<TradePartyIdentificationQuery8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Brkr", skip_serializing_if = "Option::is_none") )]
	pub brkr: Option<TradePartyIdentificationQuery8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CCP", skip_serializing_if = "Option::is_none") )]
	pub ccp: Option<TradePartyIdentificationQuery8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AgtLndr", skip_serializing_if = "Option::is_none") )]
	pub agt_lndr: Option<TradePartyIdentificationQuery8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrptyAgt", skip_serializing_if = "Option::is_none") )]
	pub trpty_agt: Option<TradePartyIdentificationQuery8>,
}

impl TradePartyQueryCriteria5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.oprtr.validate()?;
		if let Some(ref val) = self.rptg_ctr_pty { val.validate()? }
		if let Some(ref val) = self.rptg_ctr_pty_brnch { val.validate()? }
		if let Some(ref val) = self.othr_ctr_pty { val.validate()? }
		if let Some(ref val) = self.othr_ctr_pty_brnch { val.validate()? }
		if let Some(ref val) = self.bnfcry { val.validate()? }
		if let Some(ref val) = self.submitg_agt { val.validate()? }
		if let Some(ref val) = self.brkr { val.validate()? }
		if let Some(ref val) = self.ccp { val.validate()? }
		if let Some(ref val) = self.agt_lndr { val.validate()? }
		if let Some(ref val) = self.trpty_agt { val.validate()? }
		Ok(())
	}
}


// TradePartyQueryCriteria7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradePartyQueryCriteria7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Oprtr") )]
	pub oprtr: Operation3Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgCtrPty", skip_serializing_if = "Option::is_none") )]
	pub rptg_ctr_pty: Option<TradePartyIdentificationQuery10Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrCtrPty", skip_serializing_if = "Option::is_none") )]
	pub othr_ctr_pty: Option<TradePartyIdentificationQuery10Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Bnfcry", skip_serializing_if = "Option::is_none") )]
	pub bnfcry: Option<TradePartyIdentificationQuery10Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NttyRspnsblForRpt", skip_serializing_if = "Option::is_none") )]
	pub ntty_rspnsbl_for_rpt: Option<TradePartyIdentificationQuery11Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubmitgAgt", skip_serializing_if = "Option::is_none") )]
	pub submitg_agt: Option<TradePartyIdentificationQuery11Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Brkr", skip_serializing_if = "Option::is_none") )]
	pub brkr: Option<TradePartyIdentificationQuery11Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CCP", skip_serializing_if = "Option::is_none") )]
	pub ccp: Option<TradePartyIdentificationQuery11Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrMmb", skip_serializing_if = "Option::is_none") )]
	pub clr_mmb: Option<TradePartyIdentificationQuery10Choice>,
}

impl TradePartyQueryCriteria7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.oprtr.validate()?;
		if let Some(ref val) = self.rptg_ctr_pty { val.validate()? }
		if let Some(ref val) = self.othr_ctr_pty { val.validate()? }
		if let Some(ref val) = self.bnfcry { val.validate()? }
		if let Some(ref val) = self.ntty_rspnsbl_for_rpt { val.validate()? }
		if let Some(ref val) = self.submitg_agt { val.validate()? }
		if let Some(ref val) = self.brkr { val.validate()? }
		if let Some(ref val) = self.ccp { val.validate()? }
		if let Some(ref val) = self.clr_mmb { val.validate()? }
		Ok(())
	}
}


// TradeQueryCriteria10 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeQueryCriteria10 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradLifeCyclHstry") )]
	pub trad_life_cycl_hstry: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OutsdngTradInd") )]
	pub outsdng_trad_ind: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradPtyCrit", skip_serializing_if = "Option::is_none") )]
	pub trad_pty_crit: Option<TradePartyQueryCriteria5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradTpCrit", skip_serializing_if = "Option::is_none") )]
	pub trad_tp_crit: Option<TradeTypeQueryCriteria2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TmCrit", skip_serializing_if = "Option::is_none") )]
	pub tm_crit: Option<TradeDateTimeQueryCriteria2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrCrit", skip_serializing_if = "Option::is_none") )]
	pub othr_crit: Option<TradeAdditionalQueryCriteria7>,
}

impl TradeQueryCriteria10 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.trad_pty_crit { val.validate()? }
		if let Some(ref val) = self.trad_tp_crit { val.validate()? }
		if let Some(ref val) = self.tm_crit { val.validate()? }
		if let Some(ref val) = self.othr_crit { val.validate()? }
		Ok(())
	}
}


// TradeQueryCriteria14 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeQueryCriteria14 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradLifeCyclHstry", skip_serializing_if = "Option::is_none") )]
	pub trad_life_cycl_hstry: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MrgnLifeCyclHstry", skip_serializing_if = "Option::is_none") )]
	pub mrgn_life_cycl_hstry: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OutsdngTradInd") )]
	pub outsdng_trad_ind: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradPtyCrit", skip_serializing_if = "Option::is_none") )]
	pub trad_pty_crit: Option<TradePartyQueryCriteria7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmCrit", skip_serializing_if = "Option::is_none") )]
	pub fin_instrm_crit: Option<TradeSecurityIdentificationQueryCriteria3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TmCrit", skip_serializing_if = "Option::is_none") )]
	pub tm_crit: Option<TradeDateTimeQueryCriteria6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrCrit", skip_serializing_if = "Option::is_none") )]
	pub othr_crit: Option<TradeAdditionalQueryCriteria9>,
}

impl TradeQueryCriteria14 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.trad_pty_crit { val.validate()? }
		if let Some(ref val) = self.fin_instrm_crit { val.validate()? }
		if let Some(ref val) = self.tm_crit { val.validate()? }
		if let Some(ref val) = self.othr_crit { val.validate()? }
		Ok(())
	}
}


// TradeQueryExecutionFrequency3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeQueryExecutionFrequency3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrqcyTp") )]
	pub frqcy_tp: Frequency14Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DlvryDay", skip_serializing_if = "Option::is_none") )]
	pub dlvry_day: Option<Vec<WeekDay3Code>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DayOfMnth", skip_serializing_if = "Option::is_none") )]
	pub day_of_mnth: Option<Vec<f64>>,
}

impl TradeQueryExecutionFrequency3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.frqcy_tp.validate()?;
		if let Some(ref vec) = self.dlvry_day { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TradeRecurrentQuery5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeRecurrentQuery5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "QryTp") )]
	pub qry_tp: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Frqcy") )]
	pub frqcy: TradeQueryExecutionFrequency3,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldUntil") )]
	pub vld_until: String,
}

impl TradeRecurrentQuery5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.qry_tp.chars().count() < 1 {
			return Err(ValidationError::new(1001, "qry_tp is shorter than the minimum length of 1".to_string()));
		}
		if self.qry_tp.chars().count() > 1000 {
			return Err(ValidationError::new(1002, "qry_tp exceeds the maximum length of 1000".to_string()));
		}
		self.frqcy.validate()?;
		Ok(())
	}
}


// TradeRecurrentQuery7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeRecurrentQuery7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "QryTp") )]
	pub qry_tp: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Frqcy") )]
	pub frqcy: Vec<TradeQueryExecutionFrequency3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldUntil") )]
	pub vld_until: String,
}

impl TradeRecurrentQuery7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.qry_tp.chars().count() < 1 {
			return Err(ValidationError::new(1001, "qry_tp is shorter than the minimum length of 1".to_string()));
		}
		if self.qry_tp.chars().count() > 1000 {
			return Err(ValidationError::new(1002, "qry_tp exceeds the maximum length of 1000".to_string()));
		}
		for item in &self.frqcy { item.validate()? }
		Ok(())
	}
}


// TradeReport21Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeReport21Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "New", skip_serializing_if = "Option::is_none") )]
	pub new: Option<CollateralMarginCorrection6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Err", skip_serializing_if = "Option::is_none") )]
	pub err: Option<CollateralMarginError4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Crrctn", skip_serializing_if = "Option::is_none") )]
	pub crrctn: Option<CollateralMarginCorrection6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradUpd", skip_serializing_if = "Option::is_none") )]
	pub trad_upd: Option<CollateralMarginMarginUpdate5>,
}

impl TradeReport21Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.new { val.validate()? }
		if let Some(ref val) = self.err { val.validate()? }
		if let Some(ref val) = self.crrctn { val.validate()? }
		if let Some(ref val) = self.trad_upd { val.validate()? }
		Ok(())
	}
}


// TradeReport22Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeReport22Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "New", skip_serializing_if = "Option::is_none") )]
	pub new: Option<TradeNewTransaction13>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mod", skip_serializing_if = "Option::is_none") )]
	pub mod_attr: Option<TradeTransactionCorrection13>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Err", skip_serializing_if = "Option::is_none") )]
	pub err: Option<TradeError9>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EarlyTermntn", skip_serializing_if = "Option::is_none") )]
	pub early_termntn: Option<TradeError9>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PosCmpnt", skip_serializing_if = "Option::is_none") )]
	pub pos_cmpnt: Option<TradeTransactionPositionComponent8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollUpd", skip_serializing_if = "Option::is_none") )]
	pub coll_upd: Option<TradeTransactionCollateralUpdate8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Crrctn", skip_serializing_if = "Option::is_none") )]
	pub crrctn: Option<TradeTransactionCorrection13>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValtnUpd", skip_serializing_if = "Option::is_none") )]
	pub valtn_upd: Option<TradeValuationUpdate9>,
}

impl TradeReport22Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.new { val.validate()? }
		if let Some(ref val) = self.mod_attr { val.validate()? }
		if let Some(ref val) = self.err { val.validate()? }
		if let Some(ref val) = self.early_termntn { val.validate()? }
		if let Some(ref val) = self.pos_cmpnt { val.validate()? }
		if let Some(ref val) = self.coll_upd { val.validate()? }
		if let Some(ref val) = self.crrctn { val.validate()? }
		if let Some(ref val) = self.valtn_upd { val.validate()? }
		Ok(())
	}
}


// TradeReport33Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeReport33Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "New", skip_serializing_if = "Option::is_none") )]
	pub new: Option<TradeData43>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mod", skip_serializing_if = "Option::is_none") )]
	pub mod_attr: Option<TradeData43>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Crrctn", skip_serializing_if = "Option::is_none") )]
	pub crrctn: Option<TradeData43>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Termntn", skip_serializing_if = "Option::is_none") )]
	pub termntn: Option<TradeData43>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PosCmpnt", skip_serializing_if = "Option::is_none") )]
	pub pos_cmpnt: Option<TradeData43>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValtnUpd", skip_serializing_if = "Option::is_none") )]
	pub valtn_upd: Option<TradeData43>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cmprssn", skip_serializing_if = "Option::is_none") )]
	pub cmprssn: Option<TradeData43>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Err", skip_serializing_if = "Option::is_none") )]
	pub err: Option<TradeData43>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PortOut", skip_serializing_if = "Option::is_none") )]
	pub port_out: Option<TradeData43>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rvv", skip_serializing_if = "Option::is_none") )]
	pub rvv: Option<TradeData43>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<TradeData43>,
}

impl TradeReport33Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.new { val.validate()? }
		if let Some(ref val) = self.mod_attr { val.validate()? }
		if let Some(ref val) = self.crrctn { val.validate()? }
		if let Some(ref val) = self.termntn { val.validate()? }
		if let Some(ref val) = self.pos_cmpnt { val.validate()? }
		if let Some(ref val) = self.valtn_upd { val.validate()? }
		if let Some(ref val) = self.cmprssn { val.validate()? }
		if let Some(ref val) = self.err { val.validate()? }
		if let Some(ref val) = self.port_out { val.validate()? }
		if let Some(ref val) = self.rvv { val.validate()? }
		if let Some(ref val) = self.othr { val.validate()? }
		Ok(())
	}
}


// TradeReport34Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeReport34Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "New", skip_serializing_if = "Option::is_none") )]
	pub new: Option<MarginReportData9>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MrgnUpd", skip_serializing_if = "Option::is_none") )]
	pub mrgn_upd: Option<MarginReportData9>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Err", skip_serializing_if = "Option::is_none") )]
	pub err: Option<MarginReportData9>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Crrctn", skip_serializing_if = "Option::is_none") )]
	pub crrctn: Option<MarginReportData9>,
}

impl TradeReport34Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.new { val.validate()? }
		if let Some(ref val) = self.mrgn_upd { val.validate()? }
		if let Some(ref val) = self.err { val.validate()? }
		if let Some(ref val) = self.crrctn { val.validate()? }
		Ok(())
	}
}


// TradeReportHeader4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeReportHeader4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptExctnDt", skip_serializing_if = "Option::is_none") )]
	pub rpt_exctn_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgPgntn", skip_serializing_if = "Option::is_none") )]
	pub msg_pgntn: Option<Pagination1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbRcrds") )]
	pub nb_rcrds: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CmptntAuthrty", skip_serializing_if = "Option::is_none") )]
	pub cmptnt_authrty: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NewTradRpstryIdr", skip_serializing_if = "Option::is_none") )]
	pub new_trad_rpstry_idr: Option<OrganisationIdentification15Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgPurp", skip_serializing_if = "Option::is_none") )]
	pub rptg_purp: Option<Vec<String>>,
}

impl TradeReportHeader4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.msg_pgntn { val.validate()? }
		if let Some(ref vec) = self.cmptnt_authrty {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "cmptnt_authrty is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 100 {
					return Err(ValidationError::new(1002, "cmptnt_authrty exceeds the maximum length of 100".to_string()));
				}
			}
		}
		if let Some(ref val) = self.new_trad_rpstry_idr { val.validate()? }
		if let Some(ref vec) = self.rptg_purp {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "rptg_purp is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 100 {
					return Err(ValidationError::new(1002, "rptg_purp exceeds the maximum length of 100".to_string()));
				}
			}
		}
		Ok(())
	}
}


// TradeReportQuery13Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeReportQuery13Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AdHocQry", skip_serializing_if = "Option::is_none") )]
	pub ad_hoc_qry: Option<TradeQueryCriteria10>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RcrntQry", skip_serializing_if = "Option::is_none") )]
	pub rcrnt_qry: Option<TradeRecurrentQuery5>,
}

impl TradeReportQuery13Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ad_hoc_qry { val.validate()? }
		if let Some(ref val) = self.rcrnt_qry { val.validate()? }
		Ok(())
	}
}


// TradeReportQuery18Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeReportQuery18Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AdHocQry", skip_serializing_if = "Option::is_none") )]
	pub ad_hoc_qry: Option<TradeQueryCriteria14>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RcrntQry", skip_serializing_if = "Option::is_none") )]
	pub rcrnt_qry: Option<TradeRecurrentQuery7>,
}

impl TradeReportQuery18Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ad_hoc_qry { val.validate()? }
		if let Some(ref val) = self.rcrnt_qry { val.validate()? }
		Ok(())
	}
}


// TradeRepositoryReportingType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum TradeRepositoryReportingType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "SWOS") )]
	CodeSWOS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TWOS") )]
	CodeTWOS,
}

impl TradeRepositoryReportingType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TradeSecurityIdentificationQueryCriteria3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeSecurityIdentificationQueryCriteria3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Oprtr") )]
	pub oprtr: Operation3Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<Vec<SecurityIdentificationQueryCriteria1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctTp", skip_serializing_if = "Option::is_none") )]
	pub ctrct_tp: Option<Vec<FinancialInstrumentContractType2Code>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ISIN", skip_serializing_if = "Option::is_none") )]
	pub isin: Option<Vec<ISINQueryCriteria1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnqPdctIdr", skip_serializing_if = "Option::is_none") )]
	pub unq_pdct_idr: Option<Vec<UPIQueryCriteria1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UndrlygInstrmId", skip_serializing_if = "Option::is_none") )]
	pub undrlyg_instrm_id: Option<Vec<SecurityIdentificationQuery4Choice>>,
}

impl TradeSecurityIdentificationQueryCriteria3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.oprtr.validate()?;
		if let Some(ref vec) = self.id { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.ctrct_tp { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.isin { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.unq_pdct_idr { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.undrlyg_instrm_id { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TradeSettlement2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeSettlement2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtRef", skip_serializing_if = "Option::is_none") )]
	pub pmt_ref: Option<CreditorReferenceInformation2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DueDt", skip_serializing_if = "Option::is_none") )]
	pub due_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DuePyblAmt") )]
	pub due_pybl_amt: CurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InvcCcyXchg", skip_serializing_if = "Option::is_none") )]
	pub invc_ccy_xchg: Option<CurrencyReference3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DlvryDt", skip_serializing_if = "Option::is_none") )]
	pub dlvry_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BllgPrd", skip_serializing_if = "Option::is_none") )]
	pub bllg_prd: Option<Period2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxTtlAmt") )]
	pub tax_ttl_amt: CurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XmptnRsnCd", skip_serializing_if = "Option::is_none") )]
	pub xmptn_rsn_cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XmptnRsn", skip_serializing_if = "Option::is_none") )]
	pub xmptn_rsn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SubTtlClctdTax", skip_serializing_if = "Option::is_none") )]
	pub sub_ttl_clctd_tax: Option<Vec<SettlementSubTotalCalculatedTax2>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EarlyPmts", skip_serializing_if = "Option::is_none") )]
	pub early_pmts: Option<Vec<EarlyPayment1>>,
}

impl TradeSettlement2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.pmt_ref { val.validate()? }
		self.due_pybl_amt.validate()?;
		if let Some(ref val) = self.invc_ccy_xchg { val.validate()? }
		if let Some(ref val) = self.bllg_prd { val.validate()? }
		self.tax_ttl_amt.validate()?;
		if let Some(ref val) = self.xmptn_rsn_cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "xmptn_rsn_cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "xmptn_rsn_cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.xmptn_rsn {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "xmptn_rsn is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 500 {
				return Err(ValidationError::new(1002, "xmptn_rsn exceeds the maximum length of 500".to_string()));
			}
		}
		if let Some(ref vec) = self.sub_ttl_clctd_tax { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.early_pmts { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TradeStateReport16 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeStateReport16 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechRcrdId", skip_serializing_if = "Option::is_none") )]
	pub tech_rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtySpcfcData") )]
	pub ctr_pty_spcfc_data: CounterpartyData88,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LnData", skip_serializing_if = "Option::is_none") )]
	pub ln_data: Option<TransactionLoanData31Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollData", skip_serializing_if = "Option::is_none") )]
	pub coll_data: Option<TransactionCollateralData18Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RcncltnFlg", skip_serializing_if = "Option::is_none") )]
	pub rcncltn_flg: Option<ReconciliationFlag2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctMod") )]
	pub ctrct_mod: ContractModification3,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl TradeStateReport16 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tech_rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tech_rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "tech_rcrd_id exceeds the maximum length of 140".to_string()));
			}
		}
		self.ctr_pty_spcfc_data.validate()?;
		if let Some(ref val) = self.ln_data { val.validate()? }
		if let Some(ref val) = self.coll_data { val.validate()? }
		if let Some(ref val) = self.rcncltn_flg { val.validate()? }
		self.ctrct_mod.validate()?;
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TradeStateReport23 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeStateReport23 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtySpcfcData") )]
	pub ctr_pty_spcfc_data: Vec<CounterpartySpecificData36>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CmonTradData") )]
	pub cmon_trad_data: CommonTradeDataReport72,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechAttrbts", skip_serializing_if = "Option::is_none") )]
	pub tech_attrbts: Option<TechnicalAttributes5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PblcDssmntnData", skip_serializing_if = "Option::is_none") )]
	pub pblc_dssmntn_data: Option<DisseminationData1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl TradeStateReport23 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		for item in &self.ctr_pty_spcfc_data { item.validate()? }
		self.cmon_trad_data.validate()?;
		if let Some(ref val) = self.tech_attrbts { val.validate()? }
		if let Some(ref val) = self.pblc_dssmntn_data { val.validate()? }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TradeStateReport5Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeStateReport5Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DataSetActn", skip_serializing_if = "Option::is_none") )]
	pub data_set_actn: Option<ReportPeriodActivity1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Stat", skip_serializing_if = "Option::is_none") )]
	pub stat: Option<Vec<TradeStateReport16>>,
}

impl TradeStateReport5Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.data_set_actn { val.validate()? }
		if let Some(ref vec) = self.stat { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TradeTransaction50 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeTransaction50 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxId", skip_serializing_if = "Option::is_none") )]
	pub tx_id: Option<UniqueTransactionIdentifier2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ScndryTxId", skip_serializing_if = "Option::is_none") )]
	pub scndry_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrrTxId", skip_serializing_if = "Option::is_none") )]
	pub prr_tx_id: Option<UniqueTransactionIdentifier3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SbsqntTxId", skip_serializing_if = "Option::is_none") )]
	pub sbsqnt_tx_id: Option<UniqueTransactionIdentifier3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollPrtflCd", skip_serializing_if = "Option::is_none") )]
	pub coll_prtfl_cd: Option<CollateralPortfolioCode6Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptTrckgNb", skip_serializing_if = "Option::is_none") )]
	pub rpt_trckg_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PltfmIdr", skip_serializing_if = "Option::is_none") )]
	pub pltfm_idr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MrrrOrTrggrTx", skip_serializing_if = "Option::is_none") )]
	pub mrrr_or_trggr_tx: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxPric", skip_serializing_if = "Option::is_none") )]
	pub tx_pric: Option<PriceData2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtnlAmt", skip_serializing_if = "Option::is_none") )]
	pub ntnl_amt: Option<NotionalAmountLegs5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtnlQty", skip_serializing_if = "Option::is_none") )]
	pub ntnl_qty: Option<NotionalQuantityLegs5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Qty", skip_serializing_if = "Option::is_none") )]
	pub qty: Option<FinancialInstrumentQuantity32Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DlvryTp", skip_serializing_if = "Option::is_none") )]
	pub dlvry_tp: Option<PhysicalTransferType4Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExctnTmStmp", skip_serializing_if = "Option::is_none") )]
	pub exctn_tm_stmp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FctvDt", skip_serializing_if = "Option::is_none") )]
	pub fctv_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XprtnDt", skip_serializing_if = "Option::is_none") )]
	pub xprtn_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EarlyTermntnDt", skip_serializing_if = "Option::is_none") )]
	pub early_termntn_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmDt", skip_serializing_if = "Option::is_none") )]
	pub sttlm_dt: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MstrAgrmt", skip_serializing_if = "Option::is_none") )]
	pub mstr_agrmt: Option<MasterAgreement8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cmprssn", skip_serializing_if = "Option::is_none") )]
	pub cmprssn: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstTradRskRdctnFlg", skip_serializing_if = "Option::is_none") )]
	pub pst_trad_rsk_rdctn_flg: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstTradRskRdctnEvt", skip_serializing_if = "Option::is_none") )]
	pub pst_trad_rsk_rdctn_evt: Option<PTRREvent2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DerivEvt", skip_serializing_if = "Option::is_none") )]
	pub deriv_evt: Option<DerivativeEvent6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradConf", skip_serializing_if = "Option::is_none") )]
	pub trad_conf: Option<TradeConfirmation4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NonStdsdTerm", skip_serializing_if = "Option::is_none") )]
	pub non_stdsd_term: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradClr", skip_serializing_if = "Option::is_none") )]
	pub trad_clr: Option<TradeClearing11>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BlckTradElctn", skip_serializing_if = "Option::is_none") )]
	pub blck_trad_elctn: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LrgNtnlOffFcltyElctn", skip_serializing_if = "Option::is_none") )]
	pub lrg_ntnl_off_fclty_elctn: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstRate", skip_serializing_if = "Option::is_none") )]
	pub intrst_rate: Option<InterestRateLegs14>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ccy", skip_serializing_if = "Option::is_none") )]
	pub ccy: Option<CurrencyExchange22>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cmmdty", skip_serializing_if = "Option::is_none") )]
	pub cmmdty: Option<AssetClassCommodity7Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Optn", skip_serializing_if = "Option::is_none") )]
	pub optn: Option<OptionOrSwaption11>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NrgySpcfcAttrbts", skip_serializing_if = "Option::is_none") )]
	pub nrgy_spcfc_attrbts: Option<EnergySpecificAttribute9>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cdt", skip_serializing_if = "Option::is_none") )]
	pub cdt: Option<CreditDerivative4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrPmt", skip_serializing_if = "Option::is_none") )]
	pub othr_pmt: Option<Vec<OtherPayment5>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Packg", skip_serializing_if = "Option::is_none") )]
	pub packg: Option<Package4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradAllcnSts", skip_serializing_if = "Option::is_none") )]
	pub trad_allcn_sts: Option<AllocationIndicator1Code>,
}

impl TradeTransaction50 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tx_id { val.validate()? }
		if let Some(ref val) = self.scndry_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "scndry_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 72 {
				return Err(ValidationError::new(1002, "scndry_tx_id exceeds the maximum length of 72".to_string()));
			}
		}
		if let Some(ref val) = self.prr_tx_id { val.validate()? }
		if let Some(ref val) = self.sbsqnt_tx_id { val.validate()? }
		if let Some(ref val) = self.coll_prtfl_cd { val.validate()? }
		if let Some(ref val) = self.rpt_trckg_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rpt_trckg_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 52 {
				return Err(ValidationError::new(1002, "rpt_trckg_nb exceeds the maximum length of 52".to_string()));
			}
		}
		if let Some(ref val) = self.pltfm_idr {
			let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "pltfm_idr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.tx_pric { val.validate()? }
		if let Some(ref val) = self.ntnl_amt { val.validate()? }
		if let Some(ref val) = self.ntnl_qty { val.validate()? }
		if let Some(ref val) = self.qty { val.validate()? }
		if let Some(ref val) = self.dlvry_tp { val.validate()? }
		if let Some(ref val) = self.mstr_agrmt { val.validate()? }
		if let Some(ref val) = self.pst_trad_rsk_rdctn_evt { val.validate()? }
		if let Some(ref val) = self.deriv_evt { val.validate()? }
		if let Some(ref val) = self.trad_conf { val.validate()? }
		if let Some(ref val) = self.trad_clr { val.validate()? }
		if let Some(ref val) = self.intrst_rate { val.validate()? }
		if let Some(ref val) = self.ccy { val.validate()? }
		if let Some(ref val) = self.cmmdty { val.validate()? }
		if let Some(ref val) = self.optn { val.validate()? }
		if let Some(ref val) = self.nrgy_spcfc_attrbts { val.validate()? }
		if let Some(ref val) = self.cdt { val.validate()? }
		if let Some(ref vec) = self.othr_pmt { for item in vec { item.validate()? } }
		if let Some(ref val) = self.packg { val.validate()? }
		if let Some(ref val) = self.trad_allcn_sts { val.validate()? }
		Ok(())
	}
}


// TradeTransactionCollateralUpdate8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeTransactionCollateralUpdate8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechRcrdId", skip_serializing_if = "Option::is_none") )]
	pub tech_rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtySpcfcData") )]
	pub ctr_pty_spcfc_data: CounterpartyData88,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LnData", skip_serializing_if = "Option::is_none") )]
	pub ln_data: Option<TransactionLoanData26Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollData") )]
	pub coll_data: TransactionCollateralData18Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl TradeTransactionCollateralUpdate8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tech_rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tech_rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "tech_rcrd_id exceeds the maximum length of 140".to_string()));
			}
		}
		self.ctr_pty_spcfc_data.validate()?;
		if let Some(ref val) = self.ln_data { val.validate()? }
		self.coll_data.validate()?;
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TradeTransactionCondition2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum TradeTransactionCondition2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "SPCC") )]
	CodeSPCC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SECN") )]
	CodeSECN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SEBN") )]
	CodeSEBN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SCBN") )]
	CodeSCBN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SCRT") )]
	CodeSCRT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SERT") )]
	CodeSERT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SCCR") )]
	CodeSCCR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SECR") )]
	CodeSECR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CAST") )]
	CodeCAST,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SPPR") )]
	CodeSPPR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SPCU") )]
	CodeSPCU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SPEX") )]
	CodeSPEX,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GTDL") )]
	CodeGTDL,
}

impl TradeTransactionCondition2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TradeTransactionCondition7Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeTransactionCondition7Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<TradeTransactionCondition2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl TradeTransactionCondition7Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// TradeTransactionCorrection13 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeTransactionCorrection13 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechRcrdId", skip_serializing_if = "Option::is_none") )]
	pub tech_rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtySpcfcData") )]
	pub ctr_pty_spcfc_data: CounterpartyData88,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LnData", skip_serializing_if = "Option::is_none") )]
	pub ln_data: Option<TransactionLoanData31Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollData", skip_serializing_if = "Option::is_none") )]
	pub coll_data: Option<TransactionCollateralData18Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LvlTp") )]
	pub lvl_tp: ModificationLevel1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl TradeTransactionCorrection13 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tech_rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tech_rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "tech_rcrd_id exceeds the maximum length of 140".to_string()));
			}
		}
		self.ctr_pty_spcfc_data.validate()?;
		if let Some(ref val) = self.ln_data { val.validate()? }
		if let Some(ref val) = self.coll_data { val.validate()? }
		self.lvl_tp.validate()?;
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TradeTransactionIdentification15 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeTransactionIdentification15 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgCtrPty") )]
	pub rptg_ctr_pty: OrganisationIdentification15Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrCtrPty") )]
	pub othr_ctr_pty: PartyIdentification236Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnqTradIdr", skip_serializing_if = "Option::is_none") )]
	pub unq_trad_idr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MstrAgrmt", skip_serializing_if = "Option::is_none") )]
	pub mstr_agrmt: Option<MasterAgreement7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AgtLndr", skip_serializing_if = "Option::is_none") )]
	pub agt_lndr: Option<OrganisationIdentification15Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrptyAgt", skip_serializing_if = "Option::is_none") )]
	pub trpty_agt: Option<OrganisationIdentification15Choice>,
}

impl TradeTransactionIdentification15 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.rptg_ctr_pty.validate()?;
		self.othr_ctr_pty.validate()?;
		if let Some(ref val) = self.unq_trad_idr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "unq_trad_idr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 52 {
				return Err(ValidationError::new(1002, "unq_trad_idr exceeds the maximum length of 52".to_string()));
			}
		}
		if let Some(ref val) = self.mstr_agrmt { val.validate()? }
		if let Some(ref val) = self.agt_lndr { val.validate()? }
		if let Some(ref val) = self.trpty_agt { val.validate()? }
		Ok(())
	}
}


// TradeTransactionIdentification16 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeTransactionIdentification16 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechRcrdId", skip_serializing_if = "Option::is_none") )]
	pub tech_rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgCtrPty") )]
	pub rptg_ctr_pty: OrganisationIdentification15Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrCtrPty") )]
	pub othr_ctr_pty: PartyIdentification236Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NttyRspnsblForRpt", skip_serializing_if = "Option::is_none") )]
	pub ntty_rspnsbl_for_rpt: Option<OrganisationIdentification15Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollPrtflId", skip_serializing_if = "Option::is_none") )]
	pub coll_prtfl_id: Option<String>,
}

impl TradeTransactionIdentification16 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tech_rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tech_rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "tech_rcrd_id exceeds the maximum length of 140".to_string()));
			}
		}
		self.rptg_ctr_pty.validate()?;
		self.othr_ctr_pty.validate()?;
		if let Some(ref val) = self.ntty_rspnsbl_for_rpt { val.validate()? }
		if let Some(ref val) = self.coll_prtfl_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "coll_prtfl_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 52 {
				return Err(ValidationError::new(1002, "coll_prtfl_id exceeds the maximum length of 52".to_string()));
			}
		}
		Ok(())
	}
}


// TradeTransactionIdentification17 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeTransactionIdentification17 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechRcrdId", skip_serializing_if = "Option::is_none") )]
	pub tech_rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgCtrPty") )]
	pub rptg_ctr_pty: OrganisationIdentification15Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptSubmitgNtty") )]
	pub rpt_submitg_ntty: OrganisationIdentification15Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NttyRspnsblForRpt", skip_serializing_if = "Option::is_none") )]
	pub ntty_rspnsbl_for_rpt: Option<OrganisationIdentification15Choice>,
}

impl TradeTransactionIdentification17 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tech_rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tech_rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "tech_rcrd_id exceeds the maximum length of 140".to_string()));
			}
		}
		self.rptg_ctr_pty.validate()?;
		self.rpt_submitg_ntty.validate()?;
		if let Some(ref val) = self.ntty_rspnsbl_for_rpt { val.validate()? }
		Ok(())
	}
}


// TradeTransactionIdentification18 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeTransactionIdentification18 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgCtrPty") )]
	pub rptg_ctr_pty: OrganisationIdentification15Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrCtrPty") )]
	pub othr_ctr_pty: PartyIdentification236Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnqTradIdr", skip_serializing_if = "Option::is_none") )]
	pub unq_trad_idr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MstrAgrmt", skip_serializing_if = "Option::is_none") )]
	pub mstr_agrmt: Option<MasterAgreement7>,
}

impl TradeTransactionIdentification18 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.rptg_ctr_pty.validate()?;
		self.othr_ctr_pty.validate()?;
		if let Some(ref val) = self.unq_trad_idr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "unq_trad_idr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 52 {
				return Err(ValidationError::new(1002, "unq_trad_idr exceeds the maximum length of 52".to_string()));
			}
		}
		if let Some(ref val) = self.mstr_agrmt { val.validate()? }
		Ok(())
	}
}


// TradeTransactionIdentification19 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeTransactionIdentification19 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgCtrPty") )]
	pub rptg_ctr_pty: OrganisationIdentification15Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrCtrPty") )]
	pub othr_ctr_pty: PartyIdentification236Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NttyRspnsblForRpt", skip_serializing_if = "Option::is_none") )]
	pub ntty_rspnsbl_for_rpt: Option<OrganisationIdentification15Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnqTradIdr", skip_serializing_if = "Option::is_none") )]
	pub unq_trad_idr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MstrAgrmt", skip_serializing_if = "Option::is_none") )]
	pub mstr_agrmt: Option<MasterAgreement7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AgtLndr", skip_serializing_if = "Option::is_none") )]
	pub agt_lndr: Option<OrganisationIdentification15Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrptyAgt", skip_serializing_if = "Option::is_none") )]
	pub trpty_agt: Option<OrganisationIdentification15Choice>,
}

impl TradeTransactionIdentification19 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.rptg_ctr_pty.validate()?;
		self.othr_ctr_pty.validate()?;
		if let Some(ref val) = self.ntty_rspnsbl_for_rpt { val.validate()? }
		if let Some(ref val) = self.unq_trad_idr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "unq_trad_idr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 52 {
				return Err(ValidationError::new(1002, "unq_trad_idr exceeds the maximum length of 52".to_string()));
			}
		}
		if let Some(ref val) = self.mstr_agrmt { val.validate()? }
		if let Some(ref val) = self.agt_lndr { val.validate()? }
		if let Some(ref val) = self.trpty_agt { val.validate()? }
		Ok(())
	}
}


// TradeTransactionIdentification20 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeTransactionIdentification20 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechRcrdId", skip_serializing_if = "Option::is_none") )]
	pub tech_rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgCtrPty") )]
	pub rptg_ctr_pty: OrganisationIdentification15Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrCtrPty") )]
	pub othr_ctr_pty: PartyIdentification236Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NttyRspnsblForRpt", skip_serializing_if = "Option::is_none") )]
	pub ntty_rspnsbl_for_rpt: Option<OrganisationIdentification15Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnqTradIdr", skip_serializing_if = "Option::is_none") )]
	pub unq_trad_idr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MstrAgrmt", skip_serializing_if = "Option::is_none") )]
	pub mstr_agrmt: Option<MasterAgreement7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AgtLndr", skip_serializing_if = "Option::is_none") )]
	pub agt_lndr: Option<OrganisationIdentification15Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrptyAgt", skip_serializing_if = "Option::is_none") )]
	pub trpty_agt: Option<OrganisationIdentification15Choice>,
}

impl TradeTransactionIdentification20 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tech_rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tech_rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "tech_rcrd_id exceeds the maximum length of 140".to_string()));
			}
		}
		self.rptg_ctr_pty.validate()?;
		self.othr_ctr_pty.validate()?;
		if let Some(ref val) = self.ntty_rspnsbl_for_rpt { val.validate()? }
		if let Some(ref val) = self.unq_trad_idr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "unq_trad_idr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 52 {
				return Err(ValidationError::new(1002, "unq_trad_idr exceeds the maximum length of 52".to_string()));
			}
		}
		if let Some(ref val) = self.mstr_agrmt { val.validate()? }
		if let Some(ref val) = self.agt_lndr { val.validate()? }
		if let Some(ref val) = self.trpty_agt { val.validate()? }
		Ok(())
	}
}


// TradeTransactionIdentification24 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeTransactionIdentification24 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechRcrdId", skip_serializing_if = "Option::is_none") )]
	pub tech_rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ActnTp", skip_serializing_if = "Option::is_none") )]
	pub actn_tp: Option<TransactionOperationType10Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgTmStmp", skip_serializing_if = "Option::is_none") )]
	pub rptg_tm_stmp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DerivEvtTp", skip_serializing_if = "Option::is_none") )]
	pub deriv_evt_tp: Option<DerivativeEventType3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DerivEvtTmStmp", skip_serializing_if = "Option::is_none") )]
	pub deriv_evt_tm_stmp: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrCtrPty", skip_serializing_if = "Option::is_none") )]
	pub othr_ctr_pty: Option<PartyIdentification248Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnqIdr", skip_serializing_if = "Option::is_none") )]
	pub unq_idr: Option<UniqueTransactionIdentifier2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MstrAgrmt", skip_serializing_if = "Option::is_none") )]
	pub mstr_agrmt: Option<MasterAgreement8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollPrtflCd", skip_serializing_if = "Option::is_none") )]
	pub coll_prtfl_cd: Option<CollateralPortfolioCode5Choice>,
}

impl TradeTransactionIdentification24 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tech_rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tech_rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "tech_rcrd_id exceeds the maximum length of 140".to_string()));
			}
		}
		if let Some(ref val) = self.actn_tp { val.validate()? }
		if let Some(ref val) = self.deriv_evt_tp { val.validate()? }
		if let Some(ref val) = self.deriv_evt_tm_stmp { val.validate()? }
		if let Some(ref val) = self.othr_ctr_pty { val.validate()? }
		if let Some(ref val) = self.unq_idr { val.validate()? }
		if let Some(ref val) = self.mstr_agrmt { val.validate()? }
		if let Some(ref val) = self.coll_prtfl_cd { val.validate()? }
		Ok(())
	}
}


// TradeTransactionPositionComponent8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeTransactionPositionComponent8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechRcrdId", skip_serializing_if = "Option::is_none") )]
	pub tech_rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtySpcfcData") )]
	pub ctr_pty_spcfc_data: CounterpartyData88,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LnData", skip_serializing_if = "Option::is_none") )]
	pub ln_data: Option<TransactionLoanData32Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollData", skip_serializing_if = "Option::is_none") )]
	pub coll_data: Option<CollateralData35>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LvlTp") )]
	pub lvl_tp: ModificationLevel1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl TradeTransactionPositionComponent8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tech_rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tech_rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "tech_rcrd_id exceeds the maximum length of 140".to_string()));
			}
		}
		self.ctr_pty_spcfc_data.validate()?;
		if let Some(ref val) = self.ln_data { val.validate()? }
		if let Some(ref val) = self.coll_data { val.validate()? }
		self.lvl_tp.validate()?;
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TradeTypeQueryCriteria2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeTypeQueryCriteria2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Oprtr") )]
	pub oprtr: Operation3Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctiesFincgTxTp", skip_serializing_if = "Option::is_none") )]
	pub scties_fincg_tx_tp: Option<Vec<ExposureType10Code>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollCmpntTp", skip_serializing_if = "Option::is_none") )]
	pub coll_cmpnt_tp: Option<Vec<CollateralType6Code>>,
}

impl TradeTypeQueryCriteria2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.oprtr.validate()?;
		if let Some(ref vec) = self.scties_fincg_tx_tp { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.coll_cmpnt_tp { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TradeValuationUpdate9 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradeValuationUpdate9 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechRcrdId", skip_serializing_if = "Option::is_none") )]
	pub tech_rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtySpcfcData") )]
	pub ctr_pty_spcfc_data: CounterpartyData88,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LnData") )]
	pub ln_data: LoanData113,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl TradeValuationUpdate9 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tech_rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tech_rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "tech_rcrd_id exceeds the maximum length of 140".to_string()));
			}
		}
		self.ctr_pty_spcfc_data.validate()?;
		self.ln_data.validate()?;
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TradingCapacity7Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum TradingCapacity7Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "AGEN") )]
	CodeAGEN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRIN") )]
	CodePRIN,
}

impl TradingCapacity7Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TradingNameModification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradingNameModification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModCd", skip_serializing_if = "Option::is_none") )]
	pub mod_cd: Option<Modification1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgNm") )]
	pub tradg_nm: String,
}

impl TradingNameModification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mod_cd { val.validate()? }
		if self.tradg_nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "tradg_nm is shorter than the minimum length of 1".to_string()));
		}
		if self.tradg_nm.chars().count() > 350 {
			return Err(ValidationError::new(1002, "tradg_nm exceeds the maximum length of 350".to_string()));
		}
		Ok(())
	}
}


// TradingParameters2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradingParameters2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktId", skip_serializing_if = "Option::is_none") )]
	pub mkt_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RndLot", skip_serializing_if = "Option::is_none") )]
	pub rnd_lot: Option<FinancialInstrumentQuantity1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradLotSz", skip_serializing_if = "Option::is_none") )]
	pub trad_lot_sz: Option<FinancialInstrumentQuantity1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ScndryPlcOfListg", skip_serializing_if = "Option::is_none") )]
	pub scndry_plc_of_listg: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MinTraddNmnlQty", skip_serializing_if = "Option::is_none") )]
	pub min_tradd_nmnl_qty: Option<UnitOrFaceAmount1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MaxTraddNmnlQty", skip_serializing_if = "Option::is_none") )]
	pub max_tradd_nmnl_qty: Option<UnitOrFaceAmount1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MinTradgPricgIncrmt", skip_serializing_if = "Option::is_none") )]
	pub min_tradg_pricg_incrmt: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmryPlcOfListgId", skip_serializing_if = "Option::is_none") )]
	pub pmry_plc_of_listg_id: Option<String>,
}

impl TradingParameters2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mkt_id {
			let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "mkt_id does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.rnd_lot { val.validate()? }
		if let Some(ref val) = self.trad_lot_sz { val.validate()? }
		if let Some(ref vec) = self.scndry_plc_of_listg {
			for item in vec {
				let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
				if !pattern.is_match(&item) {
					return Err(ValidationError::new(1005, "scndry_plc_of_listg does not match the required pattern".to_string()));
				}
			}
		}
		if let Some(ref val) = self.min_tradd_nmnl_qty { val.validate()? }
		if let Some(ref val) = self.max_tradd_nmnl_qty { val.validate()? }
		if let Some(ref val) = self.pmry_plc_of_listg_id {
			let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "pmry_plc_of_listg_id does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// TradingUnderWaiversPercentage1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradingUnderWaiversPercentage1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgUdrWvrPctg") )]
	pub tradg_udr_wvr_pctg: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgVn") )]
	pub tradg_vn: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dsclmr", skip_serializing_if = "Option::is_none") )]
	pub dsclmr: Option<String>,
}

impl TradingUnderWaiversPercentage1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
		if !pattern.is_match(&self.tradg_vn) {
			return Err(ValidationError::new(1005, "tradg_vn does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.dsclmr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "dsclmr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "dsclmr exceeds the maximum length of 350".to_string()));
			}
		}
		Ok(())
	}
}


// TradingVenue2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum TradingVenue2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "APPA") )]
	CodeAPPA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CTPS") )]
	CodeCTPS,
}

impl TradingVenue2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TradingVenueAttributes1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradingVenueAttributes1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IssrReq") )]
	pub issr_req: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AdmssnApprvlDtByIssr", skip_serializing_if = "Option::is_none") )]
	pub admssn_apprvl_dt_by_issr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqForAdmssnDt", skip_serializing_if = "Option::is_none") )]
	pub req_for_admssn_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrstTradDt", skip_serializing_if = "Option::is_none") )]
	pub frst_trad_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TermntnDt", skip_serializing_if = "Option::is_none") )]
	pub termntn_dt: Option<String>,
}

impl TradingVenueAttributes1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
		if !pattern.is_match(&self.id) {
			return Err(ValidationError::new(1005, "id does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// TradingVenueAttributes2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradingVenueAttributes2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IssrReq", skip_serializing_if = "Option::is_none") )]
	pub issr_req: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AdmssnApprvlDtByIssr", skip_serializing_if = "Option::is_none") )]
	pub admssn_apprvl_dt_by_issr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqForAdmssnDt", skip_serializing_if = "Option::is_none") )]
	pub req_for_admssn_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrstTradDt", skip_serializing_if = "Option::is_none") )]
	pub frst_trad_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TermntnDt", skip_serializing_if = "Option::is_none") )]
	pub termntn_dt: Option<String>,
}

impl TradingVenueAttributes2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
		if !pattern.is_match(&self.id) {
			return Err(ValidationError::new(1005, "id does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// TradingVenueIdentification1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradingVenueIdentification1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktIdCd", skip_serializing_if = "Option::is_none") )]
	pub mkt_id_cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtlCmptntAuthrty", skip_serializing_if = "Option::is_none") )]
	pub ntl_cmptnt_authrty: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<TradingVenueIdentification2>,
}

impl TradingVenueIdentification1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mkt_id_cd {
			let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "mkt_id_cd does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.ntl_cmptnt_authrty {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "ntl_cmptnt_authrty does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.othr { val.validate()? }
		Ok(())
	}
}


// TradingVenueIdentification2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradingVenueIdentification2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: TradingVenue2Code,
}

impl TradingVenueIdentification2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
		}
		if self.id.chars().count() > 50 {
			return Err(ValidationError::new(1002, "id exceeds the maximum length of 50".to_string()));
		}
		self.tp.validate()?;
		Ok(())
	}
}


// TradingVenueType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TradingVenueType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OnVn", skip_serializing_if = "Option::is_none") )]
	pub on_vn: Option<TradeMarket2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OffVn", skip_serializing_if = "Option::is_none") )]
	pub off_vn: Option<NoReasonCode>,
}

impl TradingVenueType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.on_vn { val.validate()? }
		if let Some(ref val) = self.off_vn { val.validate()? }
		Ok(())
	}
}


// Tranche3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Tranche3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AttchmntPt", skip_serializing_if = "Option::is_none") )]
	pub attchmnt_pt: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtchmntPt", skip_serializing_if = "Option::is_none") )]
	pub dtchmnt_pt: Option<f64>,
}

impl Tranche3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TrancheIndicator3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TrancheIndicator3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Trnchd", skip_serializing_if = "Option::is_none") )]
	pub trnchd: Option<Tranche3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Utrnchd", skip_serializing_if = "Option::is_none") )]
	pub utrnchd: Option<NoReasonCode>,
}

impl TrancheIndicator3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.trnchd { val.validate()? }
		if let Some(ref val) = self.utrnchd { val.validate()? }
		Ok(())
	}
}


// Transaction159 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Transaction159 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtTo", skip_serializing_if = "Option::is_none") )]
	pub pmt_to: Option<System3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtFr", skip_serializing_if = "Option::is_none") )]
	pub pmt_fr: Option<System3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbtInd", skip_serializing_if = "Option::is_none") )]
	pub cdt_dbt_ind: Option<CreditDebitCode>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pmt", skip_serializing_if = "Option::is_none") )]
	pub pmt: Option<PaymentInstruction47>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctNtry", skip_serializing_if = "Option::is_none") )]
	pub acct_ntry: Option<CashAccountAndEntry5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctiesTxRefs", skip_serializing_if = "Option::is_none") )]
	pub scties_tx_refs: Option<SecuritiesTransactionReferences1>,
}

impl Transaction159 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.pmt_to { val.validate()? }
		if let Some(ref val) = self.pmt_fr { val.validate()? }
		if let Some(ref val) = self.cdt_dbt_ind { val.validate()? }
		if let Some(ref val) = self.pmt { val.validate()? }
		if let Some(ref val) = self.acct_ntry { val.validate()? }
		if let Some(ref val) = self.scties_tx_refs { val.validate()? }
		Ok(())
	}
}


// TransactionAgents6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionAgents6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstgAgt", skip_serializing_if = "Option::is_none") )]
	pub instg_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstdAgt", skip_serializing_if = "Option::is_none") )]
	pub instd_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgt", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgt", skip_serializing_if = "Option::is_none") )]
	pub cdtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt1", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt1: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt2", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt2: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt3", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt3: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RcvgAgt", skip_serializing_if = "Option::is_none") )]
	pub rcvg_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DlvrgAgt", skip_serializing_if = "Option::is_none") )]
	pub dlvrg_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IssgAgt", skip_serializing_if = "Option::is_none") )]
	pub issg_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmPlc", skip_serializing_if = "Option::is_none") )]
	pub sttlm_plc: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<Vec<ProprietaryAgent5>>,
}

impl TransactionAgents6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.instg_agt { val.validate()? }
		if let Some(ref val) = self.instd_agt { val.validate()? }
		if let Some(ref val) = self.dbtr_agt { val.validate()? }
		if let Some(ref val) = self.cdtr_agt { val.validate()? }
		if let Some(ref val) = self.intrmy_agt1 { val.validate()? }
		if let Some(ref val) = self.intrmy_agt2 { val.validate()? }
		if let Some(ref val) = self.intrmy_agt3 { val.validate()? }
		if let Some(ref val) = self.rcvg_agt { val.validate()? }
		if let Some(ref val) = self.dlvrg_agt { val.validate()? }
		if let Some(ref val) = self.issg_agt { val.validate()? }
		if let Some(ref val) = self.sttlm_plc { val.validate()? }
		if let Some(ref vec) = self.prtry { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TransactionAllocation1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionAllocation1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveOrHistoricCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbtInd") )]
	pub cdt_dbt_ind: CreditDebitCode,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Acct") )]
	pub acct: CashAccount40,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Purp") )]
	pub purp: Purpose2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ref") )]
	pub ref_attr: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdRefs", skip_serializing_if = "Option::is_none") )]
	pub rltd_refs: Option<Vec<References74Choice>>,
}

impl TransactionAllocation1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.amt.validate()?;
		self.cdt_dbt_ind.validate()?;
		self.acct.validate()?;
		self.purp.validate()?;
		if self.ref_attr.chars().count() < 1 {
			return Err(ValidationError::new(1001, "ref_attr is shorter than the minimum length of 1".to_string()));
		}
		if self.ref_attr.chars().count() > 35 {
			return Err(ValidationError::new(1002, "ref_attr exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref vec) = self.rltd_refs { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TransactionAmendment1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionAmendment1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pth", skip_serializing_if = "Option::is_none") )]
	pub pth: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rcrd") )]
	pub rcrd: TransactionAmendment1Choice,
}

impl TransactionAmendment1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.pth {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pth is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 2048 {
				return Err(ValidationError::new(1002, "pth exceeds the maximum length of 2048".to_string()));
			}
		}
		self.rcrd.validate()?;
		Ok(())
	}
}


// TransactionAmendment1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionAmendment1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Agt", skip_serializing_if = "Option::is_none") )]
	pub agt: Option<BranchAndFinancialInstitutionIdentification6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AnyBIC", skip_serializing_if = "Option::is_none") )]
	pub any_bic: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BICFI", skip_serializing_if = "Option::is_none") )]
	pub bicfi: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshAcct", skip_serializing_if = "Option::is_none") )]
	pub csh_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dt", skip_serializing_if = "Option::is_none") )]
	pub dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DtTm", skip_serializing_if = "Option::is_none") )]
	pub dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pty", skip_serializing_if = "Option::is_none") )]
	pub pty: Option<PartyIdentification135>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rmt", skip_serializing_if = "Option::is_none") )]
	pub rmt: Option<Remittance1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<String>,
}

impl TransactionAmendment1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.agt { val.validate()? }
		if let Some(ref val) = self.amt { val.validate()? }
		if let Some(ref val) = self.any_bic {
			let pattern = Regex::new("[A-Z0-9]{4,4}[A-Z]{2,2}[A-Z0-9]{2,2}([A-Z0-9]{3,3}){0,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "any_bic does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.bicfi {
			let pattern = Regex::new("[A-Z0-9]{4,4}[A-Z]{2,2}[A-Z0-9]{2,2}([A-Z0-9]{3,3}){0,1}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "bicfi does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.csh_acct { val.validate()? }
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.pty { val.validate()? }
		if let Some(ref val) = self.rmt { val.validate()? }
		if let Some(ref val) = self.othr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "othr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "othr exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// TransactionAndDocumentIdentification6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionAndDocumentIdentification6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxId") )]
	pub tx_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DocId", skip_serializing_if = "Option::is_none") )]
	pub doc_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CreDtTm", skip_serializing_if = "Option::is_none") )]
	pub cre_dt_tm: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CpyDplct", skip_serializing_if = "Option::is_none") )]
	pub cpy_dplct: Option<CopyDuplicate1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgOrgtr", skip_serializing_if = "Option::is_none") )]
	pub msg_orgtr: Option<PartyIdentification136>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgRcpt", skip_serializing_if = "Option::is_none") )]
	pub msg_rcpt: Option<PartyIdentification136>,
}

impl TransactionAndDocumentIdentification6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.tx_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "tx_id is shorter than the minimum length of 1".to_string()));
		}
		if self.tx_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "tx_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.doc_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "doc_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "doc_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.cre_dt_tm { val.validate()? }
		if let Some(ref val) = self.cpy_dplct { val.validate()? }
		if let Some(ref val) = self.msg_orgtr { val.validate()? }
		if let Some(ref val) = self.msg_rcpt { val.validate()? }
		Ok(())
	}
}


// TransactionCertificate4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionCertificate4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxId") )]
	pub tx_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cert") )]
	pub cert: DocumentIdentification28,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Acct", skip_serializing_if = "Option::is_none") )]
	pub acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BkAcctDmcltnCtry", skip_serializing_if = "Option::is_none") )]
	pub bk_acct_dmcltn_ctry: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amdmnt", skip_serializing_if = "Option::is_none") )]
	pub amdmnt: Option<DocumentAmendment1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CertRcrd") )]
	pub cert_rcrd: Vec<TransactionCertificateRecord2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl TransactionCertificate4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.tx_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "tx_id is shorter than the minimum length of 1".to_string()));
		}
		if self.tx_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "tx_id exceeds the maximum length of 35".to_string()));
		}
		self.cert.validate()?;
		if let Some(ref val) = self.acct { val.validate()? }
		if let Some(ref val) = self.bk_acct_dmcltn_ctry {
			let pattern = Regex::new("[A-Z]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "bk_acct_dmcltn_ctry does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.amdmnt { val.validate()? }
		for item in &self.cert_rcrd { item.validate()? }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TransactionCertificate5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionCertificate5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RfrdDoc") )]
	pub rfrd_doc: CertificateReference2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxDt") )]
	pub tx_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxTp", skip_serializing_if = "Option::is_none") )]
	pub tx_tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LclInstrm") )]
	pub lcl_instrm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt") )]
	pub amt: ActiveCurrencyAndAmount,
}

impl TransactionCertificate5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.rfrd_doc.validate()?;
		if let Some(ref val) = self.tx_tp {
			let pattern = Regex::new("[0-9]").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "tx_tp does not match the required pattern".to_string()));
			}
		}
		let pattern = Regex::new("[0-9]{5}").unwrap();
		if !pattern.is_match(&self.lcl_instrm) {
			return Err(ValidationError::new(1005, "lcl_instrm does not match the required pattern".to_string()));
		}
		self.amt.validate()?;
		Ok(())
	}
}


// TransactionCertificateContract2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionCertificateContract2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctRef", skip_serializing_if = "Option::is_none") )]
	pub ctrct_ref: Option<ContractRegistrationReference2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxAmtInCtrctCcy", skip_serializing_if = "Option::is_none") )]
	pub tx_amt_in_ctrct_ccy: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XpctdShipmntDt", skip_serializing_if = "Option::is_none") )]
	pub xpctd_shipmnt_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XpctdAdvncPmtRtrDt", skip_serializing_if = "Option::is_none") )]
	pub xpctd_advnc_pmt_rtr_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<String>,
}

impl TransactionCertificateContract2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ctrct_ref { val.validate()? }
		if let Some(ref val) = self.tx_amt_in_ctrct_ccy { val.validate()? }
		if let Some(ref val) = self.addtl_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 1025 {
				return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 1025".to_string()));
			}
		}
		Ok(())
	}
}


// TransactionCertificateRecord2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionCertificateRecord2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CertRcrdId") )]
	pub cert_rcrd_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DocSubmitgPrcdr", skip_serializing_if = "Option::is_none") )]
	pub doc_submitg_prcdr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tx") )]
	pub tx: TransactionCertificate5,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ctrct", skip_serializing_if = "Option::is_none") )]
	pub ctrct: Option<TransactionCertificateContract2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Attchmnt", skip_serializing_if = "Option::is_none") )]
	pub attchmnt: Option<Vec<DocumentGeneralInformation5>>,
}

impl TransactionCertificateRecord2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.cert_rcrd_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "cert_rcrd_id is shorter than the minimum length of 1".to_string()));
		}
		if self.cert_rcrd_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "cert_rcrd_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.doc_submitg_prcdr {
			let pattern = Regex::new("[0-9]").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "doc_submitg_prcdr does not match the required pattern".to_string()));
			}
		}
		self.tx.validate()?;
		if let Some(ref val) = self.ctrct { val.validate()? }
		if let Some(ref vec) = self.attchmnt { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TransactionChannel1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum TransactionChannel1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "MAIL") )]
	CodeMAIL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TLPH") )]
	CodeTLPH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ECOM") )]
	CodeECOM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TVPY") )]
	CodeTVPY,
}

impl TransactionChannel1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TransactionChannel2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum TransactionChannel2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "FIAD") )]
	CodeFIAD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HOBA") )]
	CodeHOBA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BRAN") )]
	CodeBRAN,
}

impl TransactionChannel2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TransactionChannelType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionChannelType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<TransactionChannel2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl TransactionChannelType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// TransactionCollateralData18Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionCollateralData18Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RpTrad", skip_serializing_if = "Option::is_none") )]
	pub rp_trad: Option<Collateral52>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BuySellBck", skip_serializing_if = "Option::is_none") )]
	pub buy_sell_bck: Option<Collateral52>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctiesLndg", skip_serializing_if = "Option::is_none") )]
	pub scties_lndg: Option<CollateralFlag13Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MrgnLndg", skip_serializing_if = "Option::is_none") )]
	pub mrgn_lndg: Option<Vec<Security55>>,
}

impl TransactionCollateralData18Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rp_trad { val.validate()? }
		if let Some(ref val) = self.buy_sell_bck { val.validate()? }
		if let Some(ref val) = self.scties_lndg { val.validate()? }
		if let Some(ref vec) = self.mrgn_lndg { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TransactionCounterpartyData11 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionCounterpartyData11 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Bnfcry", skip_serializing_if = "Option::is_none") )]
	pub bnfcry: Option<PartyIdentification236Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrptyAgt", skip_serializing_if = "Option::is_none") )]
	pub trpty_agt: Option<OrganisationIdentification15Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Brkr", skip_serializing_if = "Option::is_none") )]
	pub brkr: Option<OrganisationIdentification15Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrMmb", skip_serializing_if = "Option::is_none") )]
	pub clr_mmb: Option<OrganisationIdentification15Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmPties", skip_serializing_if = "Option::is_none") )]
	pub sttlm_pties: Option<SettlementParties34Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AgtLndr", skip_serializing_if = "Option::is_none") )]
	pub agt_lndr: Option<OrganisationIdentification15Choice>,
}

impl TransactionCounterpartyData11 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.bnfcry { val.validate()? }
		if let Some(ref val) = self.trpty_agt { val.validate()? }
		if let Some(ref val) = self.brkr { val.validate()? }
		if let Some(ref val) = self.clr_mmb { val.validate()? }
		if let Some(ref val) = self.sttlm_pties { val.validate()? }
		if let Some(ref val) = self.agt_lndr { val.validate()? }
		Ok(())
	}
}


// TransactionCriteria11 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionCriteria11 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NewQryNm", skip_serializing_if = "Option::is_none") )]
	pub new_qry_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SchCrit", skip_serializing_if = "Option::is_none") )]
	pub sch_crit: Option<Vec<TransactionSearchCriteria11>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StmtRpt", skip_serializing_if = "Option::is_none") )]
	pub stmt_rpt: Option<ReportIndicator1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RtrCrit", skip_serializing_if = "Option::is_none") )]
	pub rtr_crit: Option<TransactionReturnCriteria5>,
}

impl TransactionCriteria11 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.new_qry_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "new_qry_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "new_qry_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref vec) = self.sch_crit { for item in vec { item.validate()? } }
		if let Some(ref val) = self.stmt_rpt { val.validate()? }
		if let Some(ref val) = self.rtr_crit { val.validate()? }
		Ok(())
	}
}


// TransactionCriteria8Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionCriteria8Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "QryNm", skip_serializing_if = "Option::is_none") )]
	pub qry_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NewCrit", skip_serializing_if = "Option::is_none") )]
	pub new_crit: Option<TransactionCriteria11>,
}

impl TransactionCriteria8Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.qry_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "qry_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "qry_nm exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.new_crit { val.validate()? }
		Ok(())
	}
}


// TransactionData3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionData3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxPric", skip_serializing_if = "Option::is_none") )]
	pub tx_pric: Option<SecuritiesTransactionPrice4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TraddQty", skip_serializing_if = "Option::is_none") )]
	pub tradd_qty: Option<FinancialInstrumentQuantity25Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PssvOrAggrssvInd", skip_serializing_if = "Option::is_none") )]
	pub pssv_or_aggrssv_ind: Option<PassiveOrAgressiveType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StrtgyLkdOrdrId", skip_serializing_if = "Option::is_none") )]
	pub strtgy_lkd_ordr_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxId", skip_serializing_if = "Option::is_none") )]
	pub tx_id: Option<String>,
}

impl TransactionData3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tx_pric { val.validate()? }
		if let Some(ref val) = self.tradd_qty { val.validate()? }
		if let Some(ref val) = self.pssv_or_aggrssv_ind { val.validate()? }
		if let Some(ref val) = self.strtgy_lkd_ordr_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "strtgy_lkd_ordr_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 50 {
				return Err(ValidationError::new(1002, "strtgy_lkd_ordr_id exceeds the maximum length of 50".to_string()));
			}
		}
		if let Some(ref val) = self.tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 52 {
				return Err(ValidationError::new(1002, "tx_id exceeds the maximum length of 52".to_string()));
			}
		}
		Ok(())
	}
}


// TransactionDates3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionDates3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AccptncDtTm", skip_serializing_if = "Option::is_none") )]
	pub accptnc_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradActvtyCtrctlSttlmDt", skip_serializing_if = "Option::is_none") )]
	pub trad_actvty_ctrctl_sttlm_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradDt", skip_serializing_if = "Option::is_none") )]
	pub trad_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBkSttlmDt", skip_serializing_if = "Option::is_none") )]
	pub intr_bk_sttlm_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StartDt", skip_serializing_if = "Option::is_none") )]
	pub start_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndDt", skip_serializing_if = "Option::is_none") )]
	pub end_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxDtTm", skip_serializing_if = "Option::is_none") )]
	pub tx_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<Vec<ProprietaryDate3>>,
}

impl TransactionDates3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.prtry { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TransactionEnvironment1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum TransactionEnvironment1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "MERC") )]
	CodeMERC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRIV") )]
	CodePRIV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PUBL") )]
	CodePUBL,
}

impl TransactionEnvironment1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TransactionIdentification3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionIdentification3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tx", skip_serializing_if = "Option::is_none") )]
	pub tx: Option<TradeTransactionIdentification20>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MrgnRptg", skip_serializing_if = "Option::is_none") )]
	pub mrgn_rptg: Option<TradeTransactionIdentification16>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollReuse", skip_serializing_if = "Option::is_none") )]
	pub coll_reuse: Option<TradeTransactionIdentification17>,
}

impl TransactionIdentification3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tx { val.validate()? }
		if let Some(ref val) = self.mrgn_rptg { val.validate()? }
		if let Some(ref val) = self.coll_reuse { val.validate()? }
		Ok(())
	}
}


// TransactionIdentifications24 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionIdentifications24 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctOwnrTxId") )]
	pub acct_ownr_tx_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcrTxId", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktInfrstrctrTxId", skip_serializing_if = "Option::is_none") )]
	pub mkt_infrstrctr_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrcrTxId", skip_serializing_if = "Option::is_none") )]
	pub prcr_tx_id: Option<String>,
}

impl TransactionIdentifications24 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.acct_ownr_tx_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "acct_ownr_tx_id is shorter than the minimum length of 1".to_string()));
		}
		if self.acct_ownr_tx_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "acct_ownr_tx_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.acct_svcr_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_svcr_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acct_svcr_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.mkt_infrstrctr_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mkt_infrstrctr_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "mkt_infrstrctr_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.prcr_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prcr_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prcr_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// TransactionIdentifier1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionIdentifier1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxDtTm") )]
	pub tx_dt_tm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxRef") )]
	pub tx_ref: String,
}

impl TransactionIdentifier1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.tx_ref.chars().count() < 1 {
			return Err(ValidationError::new(1001, "tx_ref is shorter than the minimum length of 1".to_string()));
		}
		if self.tx_ref.chars().count() > 35 {
			return Err(ValidationError::new(1002, "tx_ref exceeds the maximum length of 35".to_string()));
		}
		Ok(())
	}
}


// TransactionIndividualStatus1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum TransactionIndividualStatus1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACTC") )]
	CodeACTC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RJCT") )]
	CodeRJCT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PDNG") )]
	CodePDNG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACCP") )]
	CodeACCP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACSP") )]
	CodeACSP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACSC") )]
	CodeACSC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACCR") )]
	CodeACCR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACWC") )]
	CodeACWC,
}

impl TransactionIndividualStatus1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TransactionInterest4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionInterest4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlIntrstAndTaxAmt", skip_serializing_if = "Option::is_none") )]
	pub ttl_intrst_and_tax_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rcrd", skip_serializing_if = "Option::is_none") )]
	pub rcrd: Option<Vec<InterestRecord2>>,
}

impl TransactionInterest4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ttl_intrst_and_tax_amt { val.validate()? }
		if let Some(ref vec) = self.rcrd { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TransactionLoanData26Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionLoanData26Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RpTrad", skip_serializing_if = "Option::is_none") )]
	pub rp_trad: Option<LoanData120>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BuySellBck", skip_serializing_if = "Option::is_none") )]
	pub buy_sell_bck: Option<LoanData120>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctiesLndg", skip_serializing_if = "Option::is_none") )]
	pub scties_lndg: Option<LoanData120>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MrgnLndg", skip_serializing_if = "Option::is_none") )]
	pub mrgn_lndg: Option<LoanData120>,
}

impl TransactionLoanData26Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rp_trad { val.validate()? }
		if let Some(ref val) = self.buy_sell_bck { val.validate()? }
		if let Some(ref val) = self.scties_lndg { val.validate()? }
		if let Some(ref val) = self.mrgn_lndg { val.validate()? }
		Ok(())
	}
}


// TransactionLoanData30Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionLoanData30Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RpTrad", skip_serializing_if = "Option::is_none") )]
	pub rp_trad: Option<LoanData135>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BuySellBck", skip_serializing_if = "Option::is_none") )]
	pub buy_sell_bck: Option<LoanData136>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctiesLndg", skip_serializing_if = "Option::is_none") )]
	pub scties_lndg: Option<LoanData137>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MrgnLndg", skip_serializing_if = "Option::is_none") )]
	pub mrgn_lndg: Option<LoanData138>,
}

impl TransactionLoanData30Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rp_trad { val.validate()? }
		if let Some(ref val) = self.buy_sell_bck { val.validate()? }
		if let Some(ref val) = self.scties_lndg { val.validate()? }
		if let Some(ref val) = self.mrgn_lndg { val.validate()? }
		Ok(())
	}
}


// TransactionLoanData31Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionLoanData31Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RpTrad", skip_serializing_if = "Option::is_none") )]
	pub rp_trad: Option<LoanData139>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BuySellBck", skip_serializing_if = "Option::is_none") )]
	pub buy_sell_bck: Option<LoanData140>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctiesLndg", skip_serializing_if = "Option::is_none") )]
	pub scties_lndg: Option<LoanData141>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MrgnLndg", skip_serializing_if = "Option::is_none") )]
	pub mrgn_lndg: Option<LoanData142>,
}

impl TransactionLoanData31Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rp_trad { val.validate()? }
		if let Some(ref val) = self.buy_sell_bck { val.validate()? }
		if let Some(ref val) = self.scties_lndg { val.validate()? }
		if let Some(ref val) = self.mrgn_lndg { val.validate()? }
		Ok(())
	}
}


// TransactionLoanData32Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionLoanData32Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RpTrad", skip_serializing_if = "Option::is_none") )]
	pub rp_trad: Option<LoanData143>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BuySellBck", skip_serializing_if = "Option::is_none") )]
	pub buy_sell_bck: Option<LoanData144>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SctiesLndg", skip_serializing_if = "Option::is_none") )]
	pub scties_lndg: Option<LoanData145>,
}

impl TransactionLoanData32Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rp_trad { val.validate()? }
		if let Some(ref val) = self.buy_sell_bck { val.validate()? }
		if let Some(ref val) = self.scties_lndg { val.validate()? }
		Ok(())
	}
}


// TransactionMatchingCriteria7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionMatchingCriteria7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptTrckgNb", skip_serializing_if = "Option::is_none") )]
	pub rpt_trckg_nb: Option<CompareText2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnqTxIdr", skip_serializing_if = "Option::is_none") )]
	pub unq_tx_idr: Option<CompareUniqueTransactionIdentifier2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrrUnqTxIdr", skip_serializing_if = "Option::is_none") )]
	pub prr_unq_tx_idr: Option<CompareUniqueTransactionIdentifier2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SbsqntPosUnqTxIdr", skip_serializing_if = "Option::is_none") )]
	pub sbsqnt_pos_unq_tx_idr: Option<CompareUniqueTransactionIdentifier2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dlta", skip_serializing_if = "Option::is_none") )]
	pub dlta: Option<CompareLongFraction19DecimalNumber1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradConf", skip_serializing_if = "Option::is_none") )]
	pub trad_conf: Option<CompareTradeConfirmation2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradClrOblgtn", skip_serializing_if = "Option::is_none") )]
	pub trad_clr_oblgtn: Option<CompareTradeClearingObligation1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradClrSts", skip_serializing_if = "Option::is_none") )]
	pub trad_clr_sts: Option<CompareTradeClearingStatus3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MstrAgrmtTp", skip_serializing_if = "Option::is_none") )]
	pub mstr_agrmt_tp: Option<CompareMasterAgreementType1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MstrAgrmtVrsn", skip_serializing_if = "Option::is_none") )]
	pub mstr_agrmt_vrsn: Option<CompareMax50Text1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntraGrp", skip_serializing_if = "Option::is_none") )]
	pub intra_grp: Option<CompareTrueFalseIndicator3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstTradRskRdctn", skip_serializing_if = "Option::is_none") )]
	pub pst_trad_rsk_rdctn: Option<ComparePostTradeRiskReduction2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DerivEvt", skip_serializing_if = "Option::is_none") )]
	pub deriv_evt: Option<CompareDerivativeEvent1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PltfmIdr", skip_serializing_if = "Option::is_none") )]
	pub pltfm_idr: Option<CompareMICIdentifier3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ExctnTmStmp", skip_serializing_if = "Option::is_none") )]
	pub exctn_tm_stmp: Option<CompareDateTime3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FctvDt", skip_serializing_if = "Option::is_none") )]
	pub fctv_dt: Option<CompareDate3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XprtnDt", skip_serializing_if = "Option::is_none") )]
	pub xprtn_dt: Option<CompareDate3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EarlyTermntnDt", skip_serializing_if = "Option::is_none") )]
	pub early_termntn_dt: Option<CompareDate3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmDt", skip_serializing_if = "Option::is_none") )]
	pub sttlm_dt: Option<Vec<CompareDate3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DlvryTp", skip_serializing_if = "Option::is_none") )]
	pub dlvry_tp: Option<CompareDeliveryType1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxPric", skip_serializing_if = "Option::is_none") )]
	pub tx_pric: Option<CompareUnitPrice5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PricSchdlUadjstdFctvDt", skip_serializing_if = "Option::is_none") )]
	pub pric_schdl_uadjstd_fctv_dt: Option<Vec<CompareDate3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PricSchdlUadjstdEndDt", skip_serializing_if = "Option::is_none") )]
	pub pric_schdl_uadjstd_end_dt: Option<Vec<CompareDate3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxSchdlPric", skip_serializing_if = "Option::is_none") )]
	pub tx_schdl_pric: Option<Vec<CompareUnitPrice5>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PackgPric", skip_serializing_if = "Option::is_none") )]
	pub packg_pric: Option<CompareUnitPrice5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtnlAmtFrstLeg", skip_serializing_if = "Option::is_none") )]
	pub ntnl_amt_frst_leg: Option<CompareAmountAndDirection3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtnlAmtFrstLegUadjstdFctvDt", skip_serializing_if = "Option::is_none") )]
	pub ntnl_amt_frst_leg_uadjstd_fctv_dt: Option<Vec<CompareDate3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtnlAmtFrstLegUadjstdEndDt", skip_serializing_if = "Option::is_none") )]
	pub ntnl_amt_frst_leg_uadjstd_end_dt: Option<Vec<CompareDate3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtnlAmtFrstLegSchdlAmt", skip_serializing_if = "Option::is_none") )]
	pub ntnl_amt_frst_leg_schdl_amt: Option<Vec<CompareAmountAndDirection3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtnlQtyFrstLeg", skip_serializing_if = "Option::is_none") )]
	pub ntnl_qty_frst_leg: Option<CompareLongFraction19DecimalNumber1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtnlQtyFrstLegUadjstdFctvDt", skip_serializing_if = "Option::is_none") )]
	pub ntnl_qty_frst_leg_uadjstd_fctv_dt: Option<Vec<CompareDate3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtnlQtyFrstLegUadjstdEndDt", skip_serializing_if = "Option::is_none") )]
	pub ntnl_qty_frst_leg_uadjstd_end_dt: Option<Vec<CompareDate3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtnlQtyFrstLegSchdlQty", skip_serializing_if = "Option::is_none") )]
	pub ntnl_qty_frst_leg_schdl_qty: Option<Vec<CompareLongFraction19DecimalNumber1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtnlAmtScndLeg", skip_serializing_if = "Option::is_none") )]
	pub ntnl_amt_scnd_leg: Option<CompareAmountAndDirection3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtnlAmtScndLegUadjstdFctvDt", skip_serializing_if = "Option::is_none") )]
	pub ntnl_amt_scnd_leg_uadjstd_fctv_dt: Option<Vec<CompareDate3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtnlAmtScndLegUadjstdEndDt", skip_serializing_if = "Option::is_none") )]
	pub ntnl_amt_scnd_leg_uadjstd_end_dt: Option<Vec<CompareDate3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtnlAmtScndLegSchdlAmt", skip_serializing_if = "Option::is_none") )]
	pub ntnl_amt_scnd_leg_schdl_amt: Option<Vec<CompareAmountAndDirection3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtnlQtyScndLeg", skip_serializing_if = "Option::is_none") )]
	pub ntnl_qty_scnd_leg: Option<CompareLongFraction19DecimalNumber1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtnlQtyScndLegUadjstdFctvDt", skip_serializing_if = "Option::is_none") )]
	pub ntnl_qty_scnd_leg_uadjstd_fctv_dt: Option<Vec<CompareDate3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtnlQtyScndLegUadjstdEndDt", skip_serializing_if = "Option::is_none") )]
	pub ntnl_qty_scnd_leg_uadjstd_end_dt: Option<Vec<CompareDate3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NtnlQtyScndLegSchdlQty", skip_serializing_if = "Option::is_none") )]
	pub ntnl_qty_scnd_leg_schdl_qty: Option<Vec<CompareLongFraction19DecimalNumber1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrPmt", skip_serializing_if = "Option::is_none") )]
	pub othr_pmt: Option<Vec<CompareOtherPayment1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstFxdRateFrstLeg", skip_serializing_if = "Option::is_none") )]
	pub intrst_fxd_rate_frst_leg: Option<CompareUnitPrice7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstFxdRateFrstLegDayCnt", skip_serializing_if = "Option::is_none") )]
	pub intrst_fxd_rate_frst_leg_day_cnt: Option<CompareDayCount1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstFxdRateFrstLegPmtFrqcyUnit", skip_serializing_if = "Option::is_none") )]
	pub intrst_fxd_rate_frst_leg_pmt_frqcy_unit: Option<CompareFrequencyUnit1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstFxdRateFrstLegPmtFrqcyVal", skip_serializing_if = "Option::is_none") )]
	pub intrst_fxd_rate_frst_leg_pmt_frqcy_val: Option<CompareNumber5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstFltgRateFrstLegId", skip_serializing_if = "Option::is_none") )]
	pub intrst_fltg_rate_frst_leg_id: Option<CompareISINIdentifier4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstFltgRateFrstLegCd", skip_serializing_if = "Option::is_none") )]
	pub intrst_fltg_rate_frst_leg_cd: Option<CompareBenchmarkCode1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstFltgRateFrstLegNm", skip_serializing_if = "Option::is_none") )]
	pub intrst_fltg_rate_frst_leg_nm: Option<CompareMax350Text1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstFltgRateFrstLegDayCnt", skip_serializing_if = "Option::is_none") )]
	pub intrst_fltg_rate_frst_leg_day_cnt: Option<CompareDayCount1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstFltgRateFrstLegPmtFrqcyUnit", skip_serializing_if = "Option::is_none") )]
	pub intrst_fltg_rate_frst_leg_pmt_frqcy_unit: Option<CompareFrequencyUnit1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstFltgRateFrstLegPmtFrqcyVal", skip_serializing_if = "Option::is_none") )]
	pub intrst_fltg_rate_frst_leg_pmt_frqcy_val: Option<CompareNumber5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstFltgRateFrstLegRefPrdUnit", skip_serializing_if = "Option::is_none") )]
	pub intrst_fltg_rate_frst_leg_ref_prd_unit: Option<CompareFrequencyUnit1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstFltgRateFrstLegRefPrdVal", skip_serializing_if = "Option::is_none") )]
	pub intrst_fltg_rate_frst_leg_ref_prd_val: Option<CompareNumber5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstFltgRateFrstLegRstFrqcyUnit", skip_serializing_if = "Option::is_none") )]
	pub intrst_fltg_rate_frst_leg_rst_frqcy_unit: Option<CompareFrequencyUnit1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstFltgRateFrstLegRstFrqcyVal", skip_serializing_if = "Option::is_none") )]
	pub intrst_fltg_rate_frst_leg_rst_frqcy_val: Option<CompareNumber5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstFltgRateFrstLegSprd", skip_serializing_if = "Option::is_none") )]
	pub intrst_fltg_rate_frst_leg_sprd: Option<CompareUnitPrice8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstRateFxdScndLeg", skip_serializing_if = "Option::is_none") )]
	pub intrst_rate_fxd_scnd_leg: Option<CompareUnitPrice7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstFxdRateScndLegDayCnt", skip_serializing_if = "Option::is_none") )]
	pub intrst_fxd_rate_scnd_leg_day_cnt: Option<CompareDayCount1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstFxdRateScndLegPmtFrqcyUnit", skip_serializing_if = "Option::is_none") )]
	pub intrst_fxd_rate_scnd_leg_pmt_frqcy_unit: Option<CompareFrequencyUnit1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstFxdRateScndLegPmtFrqcyVal", skip_serializing_if = "Option::is_none") )]
	pub intrst_fxd_rate_scnd_leg_pmt_frqcy_val: Option<CompareNumber5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstFltgRateScndLegId", skip_serializing_if = "Option::is_none") )]
	pub intrst_fltg_rate_scnd_leg_id: Option<CompareISINIdentifier4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstFltgRateScndLegCd", skip_serializing_if = "Option::is_none") )]
	pub intrst_fltg_rate_scnd_leg_cd: Option<CompareBenchmarkCode1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstFltgRateScndLegNm", skip_serializing_if = "Option::is_none") )]
	pub intrst_fltg_rate_scnd_leg_nm: Option<CompareMax350Text1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstFltgRateScndLegDayCnt", skip_serializing_if = "Option::is_none") )]
	pub intrst_fltg_rate_scnd_leg_day_cnt: Option<CompareDayCount1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstFltgRateScndLegPmtFrqcyUnit", skip_serializing_if = "Option::is_none") )]
	pub intrst_fltg_rate_scnd_leg_pmt_frqcy_unit: Option<CompareFrequencyUnit1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstFltgRateScndLegPmtFrqcyVal", skip_serializing_if = "Option::is_none") )]
	pub intrst_fltg_rate_scnd_leg_pmt_frqcy_val: Option<CompareNumber5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstFltgRateScndLegRefPrdUnit", skip_serializing_if = "Option::is_none") )]
	pub intrst_fltg_rate_scnd_leg_ref_prd_unit: Option<CompareFrequencyUnit1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstFltgRateScndLegRefPrdVal", skip_serializing_if = "Option::is_none") )]
	pub intrst_fltg_rate_scnd_leg_ref_prd_val: Option<CompareNumber5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstFltgRateScndLegRstFrqcyUnit", skip_serializing_if = "Option::is_none") )]
	pub intrst_fltg_rate_scnd_leg_rst_frqcy_unit: Option<CompareFrequencyUnit1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstFltgRateScndLegRstFrqcyVal", skip_serializing_if = "Option::is_none") )]
	pub intrst_fltg_rate_scnd_leg_rst_frqcy_val: Option<CompareNumber5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrstFltgRateScndLegSprd", skip_serializing_if = "Option::is_none") )]
	pub intrst_fltg_rate_scnd_leg_sprd: Option<CompareUnitPrice8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PackgSprd", skip_serializing_if = "Option::is_none") )]
	pub packg_sprd: Option<CompareUnitPrice8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CcyXchgRate", skip_serializing_if = "Option::is_none") )]
	pub ccy_xchg_rate: Option<CompareExchangeRate1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CcyFwdXchgRate", skip_serializing_if = "Option::is_none") )]
	pub ccy_fwd_xchg_rate: Option<CompareExchangeRate1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CcyXchgRateBsis", skip_serializing_if = "Option::is_none") )]
	pub ccy_xchg_rate_bsis: Option<CompareExchangeRateBasis1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cmmdty", skip_serializing_if = "Option::is_none") )]
	pub cmmdty: Option<CompareCommodityAssetClass4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NrgyDlvryPtOrZone", skip_serializing_if = "Option::is_none") )]
	pub nrgy_dlvry_pt_or_zone: Option<Vec<CompareDeliveryInterconnectionPoint1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NrgyIntrCnnctnPt", skip_serializing_if = "Option::is_none") )]
	pub nrgy_intr_cnnctn_pt: Option<CompareDeliveryInterconnectionPoint1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NrgyLdTp", skip_serializing_if = "Option::is_none") )]
	pub nrgy_ld_tp: Option<CompareEnergyLoadType1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DlvryAttr", skip_serializing_if = "Option::is_none") )]
	pub dlvry_attr: Option<Vec<CompareEnergyDeliveryAttribute1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OptnTp", skip_serializing_if = "Option::is_none") )]
	pub optn_tp: Option<CompareOptionType1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OptnExrcStyle", skip_serializing_if = "Option::is_none") )]
	pub optn_exrc_style: Option<Vec<CompareOptionStyle1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OptnStrkPric", skip_serializing_if = "Option::is_none") )]
	pub optn_strk_pric: Option<CompareUnitPrice4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OptnStrkPricSchdlUadjstdFctvDt", skip_serializing_if = "Option::is_none") )]
	pub optn_strk_pric_schdl_uadjstd_fctv_dt: Option<Vec<CompareDate3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OptnStrkPricSchdlUadjstdEndDt", skip_serializing_if = "Option::is_none") )]
	pub optn_strk_pric_schdl_uadjstd_end_dt: Option<Vec<CompareDate3>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OptnStrkPricSchdlAmt", skip_serializing_if = "Option::is_none") )]
	pub optn_strk_pric_schdl_amt: Option<Vec<CompareUnitPrice4>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OptnPrmAmt", skip_serializing_if = "Option::is_none") )]
	pub optn_prm_amt: Option<CompareActiveOrHistoricCurrencyAndAmount4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OptnPrmPmtDt", skip_serializing_if = "Option::is_none") )]
	pub optn_prm_pmt_dt: Option<CompareDate3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OptnMtrtyDtOfUndrlyg", skip_serializing_if = "Option::is_none") )]
	pub optn_mtrty_dt_of_undrlyg: Option<CompareDate3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtSnrty", skip_serializing_if = "Option::is_none") )]
	pub cdt_snrty: Option<CompareSeniorityType1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtRefPty", skip_serializing_if = "Option::is_none") )]
	pub cdt_ref_pty: Option<CompareReferenceParty1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtSrs", skip_serializing_if = "Option::is_none") )]
	pub cdt_srs: Option<CompareNumber7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtVrsn", skip_serializing_if = "Option::is_none") )]
	pub cdt_vrsn: Option<CompareNumber7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtIndxFctr", skip_serializing_if = "Option::is_none") )]
	pub cdt_indx_fctr: Option<ComparePercentageRate3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtTrch", skip_serializing_if = "Option::is_none") )]
	pub cdt_trch: Option<CompareTrancheIndicator1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Lvl", skip_serializing_if = "Option::is_none") )]
	pub lvl: Option<CompareReportingLevelType2>,
}

impl TransactionMatchingCriteria7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rpt_trckg_nb { val.validate()? }
		if let Some(ref val) = self.unq_tx_idr { val.validate()? }
		if let Some(ref val) = self.prr_unq_tx_idr { val.validate()? }
		if let Some(ref val) = self.sbsqnt_pos_unq_tx_idr { val.validate()? }
		if let Some(ref val) = self.dlta { val.validate()? }
		if let Some(ref val) = self.trad_conf { val.validate()? }
		if let Some(ref val) = self.trad_clr_oblgtn { val.validate()? }
		if let Some(ref val) = self.trad_clr_sts { val.validate()? }
		if let Some(ref val) = self.mstr_agrmt_tp { val.validate()? }
		if let Some(ref val) = self.mstr_agrmt_vrsn { val.validate()? }
		if let Some(ref val) = self.intra_grp { val.validate()? }
		if let Some(ref val) = self.pst_trad_rsk_rdctn { val.validate()? }
		if let Some(ref val) = self.deriv_evt { val.validate()? }
		if let Some(ref val) = self.pltfm_idr { val.validate()? }
		if let Some(ref val) = self.exctn_tm_stmp { val.validate()? }
		if let Some(ref val) = self.fctv_dt { val.validate()? }
		if let Some(ref val) = self.xprtn_dt { val.validate()? }
		if let Some(ref val) = self.early_termntn_dt { val.validate()? }
		if let Some(ref vec) = self.sttlm_dt { for item in vec { item.validate()? } }
		if let Some(ref val) = self.dlvry_tp { val.validate()? }
		if let Some(ref val) = self.tx_pric { val.validate()? }
		if let Some(ref vec) = self.pric_schdl_uadjstd_fctv_dt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.pric_schdl_uadjstd_end_dt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.tx_schdl_pric { for item in vec { item.validate()? } }
		if let Some(ref val) = self.packg_pric { val.validate()? }
		if let Some(ref val) = self.ntnl_amt_frst_leg { val.validate()? }
		if let Some(ref vec) = self.ntnl_amt_frst_leg_uadjstd_fctv_dt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.ntnl_amt_frst_leg_uadjstd_end_dt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.ntnl_amt_frst_leg_schdl_amt { for item in vec { item.validate()? } }
		if let Some(ref val) = self.ntnl_qty_frst_leg { val.validate()? }
		if let Some(ref vec) = self.ntnl_qty_frst_leg_uadjstd_fctv_dt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.ntnl_qty_frst_leg_uadjstd_end_dt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.ntnl_qty_frst_leg_schdl_qty { for item in vec { item.validate()? } }
		if let Some(ref val) = self.ntnl_amt_scnd_leg { val.validate()? }
		if let Some(ref vec) = self.ntnl_amt_scnd_leg_uadjstd_fctv_dt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.ntnl_amt_scnd_leg_uadjstd_end_dt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.ntnl_amt_scnd_leg_schdl_amt { for item in vec { item.validate()? } }
		if let Some(ref val) = self.ntnl_qty_scnd_leg { val.validate()? }
		if let Some(ref vec) = self.ntnl_qty_scnd_leg_uadjstd_fctv_dt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.ntnl_qty_scnd_leg_uadjstd_end_dt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.ntnl_qty_scnd_leg_schdl_qty { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.othr_pmt { for item in vec { item.validate()? } }
		if let Some(ref val) = self.intrst_fxd_rate_frst_leg { val.validate()? }
		if let Some(ref val) = self.intrst_fxd_rate_frst_leg_day_cnt { val.validate()? }
		if let Some(ref val) = self.intrst_fxd_rate_frst_leg_pmt_frqcy_unit { val.validate()? }
		if let Some(ref val) = self.intrst_fxd_rate_frst_leg_pmt_frqcy_val { val.validate()? }
		if let Some(ref val) = self.intrst_fltg_rate_frst_leg_id { val.validate()? }
		if let Some(ref val) = self.intrst_fltg_rate_frst_leg_cd { val.validate()? }
		if let Some(ref val) = self.intrst_fltg_rate_frst_leg_nm { val.validate()? }
		if let Some(ref val) = self.intrst_fltg_rate_frst_leg_day_cnt { val.validate()? }
		if let Some(ref val) = self.intrst_fltg_rate_frst_leg_pmt_frqcy_unit { val.validate()? }
		if let Some(ref val) = self.intrst_fltg_rate_frst_leg_pmt_frqcy_val { val.validate()? }
		if let Some(ref val) = self.intrst_fltg_rate_frst_leg_ref_prd_unit { val.validate()? }
		if let Some(ref val) = self.intrst_fltg_rate_frst_leg_ref_prd_val { val.validate()? }
		if let Some(ref val) = self.intrst_fltg_rate_frst_leg_rst_frqcy_unit { val.validate()? }
		if let Some(ref val) = self.intrst_fltg_rate_frst_leg_rst_frqcy_val { val.validate()? }
		if let Some(ref val) = self.intrst_fltg_rate_frst_leg_sprd { val.validate()? }
		if let Some(ref val) = self.intrst_rate_fxd_scnd_leg { val.validate()? }
		if let Some(ref val) = self.intrst_fxd_rate_scnd_leg_day_cnt { val.validate()? }
		if let Some(ref val) = self.intrst_fxd_rate_scnd_leg_pmt_frqcy_unit { val.validate()? }
		if let Some(ref val) = self.intrst_fxd_rate_scnd_leg_pmt_frqcy_val { val.validate()? }
		if let Some(ref val) = self.intrst_fltg_rate_scnd_leg_id { val.validate()? }
		if let Some(ref val) = self.intrst_fltg_rate_scnd_leg_cd { val.validate()? }
		if let Some(ref val) = self.intrst_fltg_rate_scnd_leg_nm { val.validate()? }
		if let Some(ref val) = self.intrst_fltg_rate_scnd_leg_day_cnt { val.validate()? }
		if let Some(ref val) = self.intrst_fltg_rate_scnd_leg_pmt_frqcy_unit { val.validate()? }
		if let Some(ref val) = self.intrst_fltg_rate_scnd_leg_pmt_frqcy_val { val.validate()? }
		if let Some(ref val) = self.intrst_fltg_rate_scnd_leg_ref_prd_unit { val.validate()? }
		if let Some(ref val) = self.intrst_fltg_rate_scnd_leg_ref_prd_val { val.validate()? }
		if let Some(ref val) = self.intrst_fltg_rate_scnd_leg_rst_frqcy_unit { val.validate()? }
		if let Some(ref val) = self.intrst_fltg_rate_scnd_leg_rst_frqcy_val { val.validate()? }
		if let Some(ref val) = self.intrst_fltg_rate_scnd_leg_sprd { val.validate()? }
		if let Some(ref val) = self.packg_sprd { val.validate()? }
		if let Some(ref val) = self.ccy_xchg_rate { val.validate()? }
		if let Some(ref val) = self.ccy_fwd_xchg_rate { val.validate()? }
		if let Some(ref val) = self.ccy_xchg_rate_bsis { val.validate()? }
		if let Some(ref val) = self.cmmdty { val.validate()? }
		if let Some(ref vec) = self.nrgy_dlvry_pt_or_zone { for item in vec { item.validate()? } }
		if let Some(ref val) = self.nrgy_intr_cnnctn_pt { val.validate()? }
		if let Some(ref val) = self.nrgy_ld_tp { val.validate()? }
		if let Some(ref vec) = self.dlvry_attr { for item in vec { item.validate()? } }
		if let Some(ref val) = self.optn_tp { val.validate()? }
		if let Some(ref vec) = self.optn_exrc_style { for item in vec { item.validate()? } }
		if let Some(ref val) = self.optn_strk_pric { val.validate()? }
		if let Some(ref vec) = self.optn_strk_pric_schdl_uadjstd_fctv_dt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.optn_strk_pric_schdl_uadjstd_end_dt { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.optn_strk_pric_schdl_amt { for item in vec { item.validate()? } }
		if let Some(ref val) = self.optn_prm_amt { val.validate()? }
		if let Some(ref val) = self.optn_prm_pmt_dt { val.validate()? }
		if let Some(ref val) = self.optn_mtrty_dt_of_undrlyg { val.validate()? }
		if let Some(ref val) = self.cdt_snrty { val.validate()? }
		if let Some(ref val) = self.cdt_ref_pty { val.validate()? }
		if let Some(ref val) = self.cdt_srs { val.validate()? }
		if let Some(ref val) = self.cdt_vrsn { val.validate()? }
		if let Some(ref val) = self.cdt_indx_fctr { val.validate()? }
		if let Some(ref val) = self.cdt_trch { val.validate()? }
		if let Some(ref val) = self.lvl { val.validate()? }
		Ok(())
	}
}


// TransactionModification7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionModification7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtId") )]
	pub pmt_id: PaymentIdentification8Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NewPmtValSet") )]
	pub new_pmt_val_set: PaymentInstruction33,
}

impl TransactionModification7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pmt_id.validate()?;
		self.new_pmt_val_set.validate()?;
		Ok(())
	}
}


// TransactionOperationType10Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum TransactionOperationType10Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "COMP") )]
	CodeCOMP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CORR") )]
	CodeCORR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EROR") )]
	CodeEROR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MODI") )]
	CodeMODI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NEWT") )]
	CodeNEWT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "POSC") )]
	CodePOSC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REVI") )]
	CodeREVI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TERM") )]
	CodeTERM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VALU") )]
	CodeVALU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MARU") )]
	CodeMARU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PRTO") )]
	CodePRTO,
}

impl TransactionOperationType10Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TransactionOperationType11Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum TransactionOperationType11Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CORR") )]
	CodeCORR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MARU") )]
	CodeMARU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NEWT") )]
	CodeNEWT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EROR") )]
	CodeEROR,
}

impl TransactionOperationType11Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TransactionOperationType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum TransactionOperationType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "AMND") )]
	CodeAMND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CANC") )]
	CodeCANC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CORR") )]
	CodeCORR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NEWT") )]
	CodeNEWT,
}

impl TransactionOperationType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TransactionOperationType4Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum TransactionOperationType4Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "NEWT") )]
	CodeNEWT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AMND") )]
	CodeAMND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CANC") )]
	CodeCANC,
}

impl TransactionOperationType4Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TransactionOperationType6Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum TransactionOperationType6Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "REUU") )]
	CodeREUU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "COLU") )]
	CodeCOLU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CORR") )]
	CodeCORR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ETRM") )]
	CodeETRM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VALU") )]
	CodeVALU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "POSC") )]
	CodePOSC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NEWT") )]
	CodeNEWT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MODI") )]
	CodeMODI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MARU") )]
	CodeMARU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EROR") )]
	CodeEROR,
}

impl TransactionOperationType6Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TransactionOperationType8Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum TransactionOperationType8Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "COMP") )]
	CodeCOMP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CORR") )]
	CodeCORR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EROR") )]
	CodeEROR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MODI") )]
	CodeMODI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NEWT") )]
	CodeNEWT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "POSC") )]
	CodePOSC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REVI") )]
	CodeREVI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TERM") )]
	CodeTERM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VALU") )]
	CodeVALU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MARU") )]
	CodeMARU,
}

impl TransactionOperationType8Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TransactionOrError6Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionOrError6Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tx", skip_serializing_if = "Option::is_none") )]
	pub tx: Option<Transaction159>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizErr", skip_serializing_if = "Option::is_none") )]
	pub biz_err: Option<Vec<ErrorHandling5>>,
}

impl TransactionOrError6Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tx { val.validate()? }
		if let Some(ref vec) = self.biz_err { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TransactionParties11 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionParties11 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtDbtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_dbtr: Option<Party50Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dbtr") )]
	pub dbtr: Party50Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitgPty", skip_serializing_if = "Option::is_none") )]
	pub initg_pty: Option<Party50Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgt", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsInstgAgt1", skip_serializing_if = "Option::is_none") )]
	pub prvs_instg_agt1: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsInstgAgt1Acct", skip_serializing_if = "Option::is_none") )]
	pub prvs_instg_agt1_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsInstgAgt2", skip_serializing_if = "Option::is_none") )]
	pub prvs_instg_agt2: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsInstgAgt2Acct", skip_serializing_if = "Option::is_none") )]
	pub prvs_instg_agt2_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsInstgAgt3", skip_serializing_if = "Option::is_none") )]
	pub prvs_instg_agt3: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrvsInstgAgt3Acct", skip_serializing_if = "Option::is_none") )]
	pub prvs_instg_agt3_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt1", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt1: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt1Acct", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt1_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt2", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt2: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt2Acct", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt2_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt3", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt3: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrmyAgt3Acct", skip_serializing_if = "Option::is_none") )]
	pub intrmy_agt3_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgt", skip_serializing_if = "Option::is_none") )]
	pub cdtr_agt: Option<BranchAndFinancialInstitutionIdentification8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAgtAcct", skip_serializing_if = "Option::is_none") )]
	pub cdtr_agt_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cdtr") )]
	pub cdtr: Party50Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAcct", skip_serializing_if = "Option::is_none") )]
	pub cdtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtCdtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_cdtr: Option<Party50Choice>,
}

impl TransactionParties11 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ultmt_dbtr { val.validate()? }
		self.dbtr.validate()?;
		if let Some(ref val) = self.dbtr_acct { val.validate()? }
		if let Some(ref val) = self.initg_pty { val.validate()? }
		if let Some(ref val) = self.dbtr_agt { val.validate()? }
		if let Some(ref val) = self.dbtr_agt_acct { val.validate()? }
		if let Some(ref val) = self.prvs_instg_agt1 { val.validate()? }
		if let Some(ref val) = self.prvs_instg_agt1_acct { val.validate()? }
		if let Some(ref val) = self.prvs_instg_agt2 { val.validate()? }
		if let Some(ref val) = self.prvs_instg_agt2_acct { val.validate()? }
		if let Some(ref val) = self.prvs_instg_agt3 { val.validate()? }
		if let Some(ref val) = self.prvs_instg_agt3_acct { val.validate()? }
		if let Some(ref val) = self.intrmy_agt1 { val.validate()? }
		if let Some(ref val) = self.intrmy_agt1_acct { val.validate()? }
		if let Some(ref val) = self.intrmy_agt2 { val.validate()? }
		if let Some(ref val) = self.intrmy_agt2_acct { val.validate()? }
		if let Some(ref val) = self.intrmy_agt3 { val.validate()? }
		if let Some(ref val) = self.intrmy_agt3_acct { val.validate()? }
		if let Some(ref val) = self.cdtr_agt { val.validate()? }
		if let Some(ref val) = self.cdtr_agt_acct { val.validate()? }
		self.cdtr.validate()?;
		if let Some(ref val) = self.cdtr_acct { val.validate()? }
		if let Some(ref val) = self.ultmt_cdtr { val.validate()? }
		Ok(())
	}
}


// TransactionParties12 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionParties12 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "InitgPty", skip_serializing_if = "Option::is_none") )]
	pub initg_pty: Option<Party50Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dbtr", skip_serializing_if = "Option::is_none") )]
	pub dbtr: Option<Party50Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DbtrAcct", skip_serializing_if = "Option::is_none") )]
	pub dbtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtDbtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_dbtr: Option<Party50Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cdtr", skip_serializing_if = "Option::is_none") )]
	pub cdtr: Option<Party50Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrAcct", skip_serializing_if = "Option::is_none") )]
	pub cdtr_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UltmtCdtr", skip_serializing_if = "Option::is_none") )]
	pub ultmt_cdtr: Option<Party50Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgPty", skip_serializing_if = "Option::is_none") )]
	pub tradg_pty: Option<Party50Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<Vec<ProprietaryParty6>>,
}

impl TransactionParties12 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.initg_pty { val.validate()? }
		if let Some(ref val) = self.dbtr { val.validate()? }
		if let Some(ref val) = self.dbtr_acct { val.validate()? }
		if let Some(ref val) = self.ultmt_dbtr { val.validate()? }
		if let Some(ref val) = self.cdtr { val.validate()? }
		if let Some(ref val) = self.cdtr_acct { val.validate()? }
		if let Some(ref val) = self.ultmt_cdtr { val.validate()? }
		if let Some(ref val) = self.tradg_pty { val.validate()? }
		if let Some(ref vec) = self.prtry { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TransactionPrice4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionPrice4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DealPric", skip_serializing_if = "Option::is_none") )]
	pub deal_pric: Option<Price7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<Vec<ProprietaryPrice2>>,
}

impl TransactionPrice4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.deal_pric { val.validate()? }
		if let Some(ref vec) = self.prtry { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TransactionProcessingStatus3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum TransactionProcessingStatus3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CAND") )]
	CodeCAND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PACK") )]
	CodePACK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REJT") )]
	CodeREJT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REPR") )]
	CodeREPR,
}

impl TransactionProcessingStatus3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TransactionQuantities3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionQuantities3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Qty", skip_serializing_if = "Option::is_none") )]
	pub qty: Option<FinancialInstrumentQuantity1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlAndCurFaceAmt", skip_serializing_if = "Option::is_none") )]
	pub orgnl_and_cur_face_amt: Option<OriginalAndCurrentQuantities1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<ProprietaryQuantity1>,
}

impl TransactionQuantities3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.qty { val.validate()? }
		if let Some(ref val) = self.orgnl_and_cur_face_amt { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// TransactionQuery8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionQuery8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "QryTp", skip_serializing_if = "Option::is_none") )]
	pub qry_tp: Option<QueryType2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxCrit", skip_serializing_if = "Option::is_none") )]
	pub tx_crit: Option<TransactionCriteria8Choice>,
}

impl TransactionQuery8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.qry_tp { val.validate()? }
		if let Some(ref val) = self.tx_crit { val.validate()? }
		Ok(())
	}
}


// TransactionReferences6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionReferences6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId", skip_serializing_if = "Option::is_none") )]
	pub msg_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcrRef", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtInfId", skip_serializing_if = "Option::is_none") )]
	pub pmt_inf_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrId", skip_serializing_if = "Option::is_none") )]
	pub instr_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndToEndId", skip_serializing_if = "Option::is_none") )]
	pub end_to_end_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UETR", skip_serializing_if = "Option::is_none") )]
	pub uetr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxId", skip_serializing_if = "Option::is_none") )]
	pub tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MndtId", skip_serializing_if = "Option::is_none") )]
	pub mndt_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChqNb", skip_serializing_if = "Option::is_none") )]
	pub chq_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrSysRef", skip_serializing_if = "Option::is_none") )]
	pub clr_sys_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctOwnrTxId", skip_serializing_if = "Option::is_none") )]
	pub acct_ownr_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcrTxId", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktInfrstrctrTxId", skip_serializing_if = "Option::is_none") )]
	pub mkt_infrstrctr_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrcgId", skip_serializing_if = "Option::is_none") )]
	pub prcg_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<Vec<ProprietaryReference1>>,
}

impl TransactionReferences6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.msg_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.acct_svcr_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_svcr_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acct_svcr_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.pmt_inf_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pmt_inf_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "pmt_inf_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.instr_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "instr_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "instr_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.end_to_end_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "end_to_end_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "end_to_end_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.uetr {
			let pattern = Regex::new("[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "uetr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.mndt_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mndt_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "mndt_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.chq_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "chq_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "chq_nb exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.clr_sys_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "clr_sys_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "clr_sys_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.acct_ownr_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_ownr_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acct_ownr_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.acct_svcr_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_svcr_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acct_svcr_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.mkt_infrstrctr_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mkt_infrstrctr_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "mkt_infrstrctr_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.prcg_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prcg_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prcg_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref vec) = self.prtry { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TransactionReferences7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionReferences7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgId", skip_serializing_if = "Option::is_none") )]
	pub msg_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MsgNmId", skip_serializing_if = "Option::is_none") )]
	pub msg_nm_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcrRef", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtInfId", skip_serializing_if = "Option::is_none") )]
	pub pmt_inf_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrId", skip_serializing_if = "Option::is_none") )]
	pub instr_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndToEndId", skip_serializing_if = "Option::is_none") )]
	pub end_to_end_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UETR", skip_serializing_if = "Option::is_none") )]
	pub uetr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxId", skip_serializing_if = "Option::is_none") )]
	pub tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MndtId", skip_serializing_if = "Option::is_none") )]
	pub mndt_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChqNb", skip_serializing_if = "Option::is_none") )]
	pub chq_nb: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClrSysRef", skip_serializing_if = "Option::is_none") )]
	pub clr_sys_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctOwnrTxId", skip_serializing_if = "Option::is_none") )]
	pub acct_ownr_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctSvcrTxId", skip_serializing_if = "Option::is_none") )]
	pub acct_svcr_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktInfrstrctrTxId", skip_serializing_if = "Option::is_none") )]
	pub mkt_infrstrctr_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrcgId", skip_serializing_if = "Option::is_none") )]
	pub prcg_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<Vec<ProprietaryReference1>>,
}

impl TransactionReferences7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.msg_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "msg_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "msg_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.msg_nm_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "msg_nm_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "msg_nm_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.acct_svcr_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_svcr_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acct_svcr_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.pmt_inf_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pmt_inf_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "pmt_inf_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.instr_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "instr_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "instr_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.end_to_end_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "end_to_end_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "end_to_end_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.uetr {
			let pattern = Regex::new("[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "uetr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.mndt_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mndt_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "mndt_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.chq_nb {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "chq_nb is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "chq_nb exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.clr_sys_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "clr_sys_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "clr_sys_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.acct_ownr_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_ownr_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acct_ownr_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.acct_svcr_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "acct_svcr_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "acct_svcr_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.mkt_infrstrctr_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mkt_infrstrctr_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "mkt_infrstrctr_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.prcg_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prcg_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prcg_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref vec) = self.prtry { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TransactionReferences8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionReferences8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtInfId", skip_serializing_if = "Option::is_none") )]
	pub pmt_inf_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrId", skip_serializing_if = "Option::is_none") )]
	pub instr_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndToEndId") )]
	pub end_to_end_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxId", skip_serializing_if = "Option::is_none") )]
	pub tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UETR", skip_serializing_if = "Option::is_none") )]
	pub uetr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MndtId", skip_serializing_if = "Option::is_none") )]
	pub mndt_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtrSchmeId", skip_serializing_if = "Option::is_none") )]
	pub cdtr_schme_id: Option<PartyIdentification272>,
}

impl TransactionReferences8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.pmt_inf_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "pmt_inf_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "pmt_inf_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.instr_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "instr_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "instr_id exceeds the maximum length of 35".to_string()));
			}
		}
		if self.end_to_end_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "end_to_end_id is shorter than the minimum length of 1".to_string()));
		}
		if self.end_to_end_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "end_to_end_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.uetr {
			let pattern = Regex::new("[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "uetr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.mndt_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "mndt_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "mndt_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.cdtr_schme_id { val.validate()? }
		Ok(())
	}
}


// TransactionReport8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionReport8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtId") )]
	pub pmt_id: PaymentIdentification8Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxOrErr") )]
	pub tx_or_err: TransactionOrError6Choice,
}

impl TransactionReport8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pmt_id.validate()?;
		self.tx_or_err.validate()?;
		Ok(())
	}
}


// TransactionReportOrError7Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionReportOrError7Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BizRpt", skip_serializing_if = "Option::is_none") )]
	pub biz_rpt: Option<Transactions11>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OprlErr", skip_serializing_if = "Option::is_none") )]
	pub oprl_err: Option<Vec<ErrorHandling5>>,
}

impl TransactionReportOrError7Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.biz_rpt { val.validate()? }
		if let Some(ref vec) = self.oprl_err { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TransactionRequestType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum TransactionRequestType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "DTTX") )]
	CodeDTTX,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OREC") )]
	CodeOREC,
}

impl TransactionRequestType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TransactionReturnCriteria5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionReturnCriteria5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtToRtrCrit", skip_serializing_if = "Option::is_none") )]
	pub pmt_to_rtr_crit: Option<SystemReturnCriteria2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtFrRtrCrit", skip_serializing_if = "Option::is_none") )]
	pub pmt_fr_rtr_crit: Option<SystemReturnCriteria2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctCshNtryRtrCrit", skip_serializing_if = "Option::is_none") )]
	pub acct_csh_ntry_rtr_crit: Option<AccountCashEntryReturnCriteria3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtRtrCrit", skip_serializing_if = "Option::is_none") )]
	pub pmt_rtr_crit: Option<PaymentReturnCriteria4>,
}

impl TransactionReturnCriteria5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.pmt_to_rtr_crit { val.validate()? }
		if let Some(ref val) = self.pmt_fr_rtr_crit { val.validate()? }
		if let Some(ref val) = self.acct_csh_ntry_rtr_crit { val.validate()? }
		if let Some(ref val) = self.pmt_rtr_crit { val.validate()? }
		Ok(())
	}
}


// TransactionSearchCriteria11 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionSearchCriteria11 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtTo", skip_serializing_if = "Option::is_none") )]
	pub pmt_to: Option<Vec<SystemSearch5>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtFr", skip_serializing_if = "Option::is_none") )]
	pub pmt_fr: Option<Vec<SystemSearch5>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtSch", skip_serializing_if = "Option::is_none") )]
	pub pmt_sch: Option<PaymentSearch10>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AcctNtrySch", skip_serializing_if = "Option::is_none") )]
	pub acct_ntry_sch: Option<CashAccountEntrySearch8>,
}

impl TransactionSearchCriteria11 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.pmt_to { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.pmt_fr { for item in vec { item.validate()? } }
		if let Some(ref val) = self.pmt_sch { val.validate()? }
		if let Some(ref val) = self.acct_ntry_sch { val.validate()? }
		Ok(())
	}
}


// TransactionStatus1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionStatus1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl TransactionStatus1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// TransactionType2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionType2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sts") )]
	pub sts: EntryStatus1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CdtDbtInd") )]
	pub cdt_dbt_ind: CreditDebitCode,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FlrLmt", skip_serializing_if = "Option::is_none") )]
	pub flr_lmt: Option<Vec<Limit2>>,
}

impl TransactionType2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.sts.validate()?;
		self.cdt_dbt_ind.validate()?;
		if let Some(ref vec) = self.flr_lmt { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TransactionType5Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionType5Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<InvestmentFundTransactionType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl TransactionType5Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// Transactions11 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Transactions11 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PmtCmonInf", skip_serializing_if = "Option::is_none") )]
	pub pmt_cmon_inf: Option<PaymentCommon6>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxsSummry", skip_serializing_if = "Option::is_none") )]
	pub txs_summry: Option<NumberAndSumOfTransactions2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxRpt") )]
	pub tx_rpt: Vec<TransactionReport8>,
}

impl Transactions11 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.pmt_cmon_inf { val.validate()? }
		if let Some(ref val) = self.txs_summry { val.validate()? }
		for item in &self.tx_rpt { item.validate()? }
		Ok(())
	}
}


// TransactionsBin2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransactionsBin2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfTxs") )]
	pub nb_of_txs: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNtnlAmt") )]
	pub ttl_ntnl_amt: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rg") )]
	pub rg: FromToQuantityRange2,
}

impl TransactionsBin2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.rg.validate()?;
		Ok(())
	}
}


// TransferInstruction1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransferInstruction1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TrfInd", skip_serializing_if = "Option::is_none") )]
	pub trf_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd") )]
	pub cd: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StartDtTm", skip_serializing_if = "Option::is_none") )]
	pub start_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StartDt", skip_serializing_if = "Option::is_none") )]
	pub start_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Desc", skip_serializing_if = "Option::is_none") )]
	pub desc: Option<String>,
}

impl TransferInstruction1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.cd.chars().count() < 1 {
			return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
		}
		if self.cd.chars().count() > 35 {
			return Err(ValidationError::new(1002, "cd exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 256 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 256".to_string()));
			}
		}
		if let Some(ref val) = self.desc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "desc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "desc exceeds the maximum length of 350".to_string()));
			}
		}
		Ok(())
	}
}


// TransparencyDataReport11 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransparencyDataReport11 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechRcrdId", skip_serializing_if = "Option::is_none") )]
	pub tech_rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FullNm", skip_serializing_if = "Option::is_none") )]
	pub full_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgVn", skip_serializing_if = "Option::is_none") )]
	pub tradg_vn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgDt", skip_serializing_if = "Option::is_none") )]
	pub rptg_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmClssfctn") )]
	pub fin_instrm_clssfctn: EquityInstrumentReportingClassification1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOutsdngInstrms", skip_serializing_if = "Option::is_none") )]
	pub nb_outsdng_instrms: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HldgsExcdgTtlVtngRghtThrshld", skip_serializing_if = "Option::is_none") )]
	pub hldgs_excdg_ttl_vtng_rght_thrshld: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IssncSz", skip_serializing_if = "Option::is_none") )]
	pub issnc_sz: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrmPric", skip_serializing_if = "Option::is_none") )]
	pub instrm_pric: Option<ActiveCurrencyAnd13DecimalAmount>,
}

impl TransparencyDataReport11 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tech_rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tech_rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tech_rcrd_id exceeds the maximum length of 35".to_string()));
			}
		}
		let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
		if !pattern.is_match(&self.id) {
			return Err(ValidationError::new(1005, "id does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.full_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "full_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "full_nm exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.tradg_vn {
			let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "tradg_vn does not match the required pattern".to_string()));
			}
		}
		self.fin_instrm_clssfctn.validate()?;
		if let Some(ref val) = self.issnc_sz { val.validate()? }
		if let Some(ref val) = self.instrm_pric { val.validate()? }
		Ok(())
	}
}


// TransparencyDataReport13 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransparencyDataReport13 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechRcrdId", skip_serializing_if = "Option::is_none") )]
	pub tech_rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgDt", skip_serializing_if = "Option::is_none") )]
	pub rptg_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgVn", skip_serializing_if = "Option::is_none") )]
	pub tradg_vn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sspnsn") )]
	pub sspnsn: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxsExctd") )]
	pub txs_exctd: NumberAndVolume2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxsExctdExclgPreTradWvr") )]
	pub txs_exctd_exclg_pre_trad_wvr: NumberAndVolume2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxsExctdExclgPstTradLrgInScaleWvr") )]
	pub txs_exctd_exclg_pst_trad_lrg_in_scale_wvr: NumberAndVolume2,
}

impl TransparencyDataReport13 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tech_rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tech_rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tech_rcrd_id exceeds the maximum length of 35".to_string()));
			}
		}
		let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
		if !pattern.is_match(&self.id) {
			return Err(ValidationError::new(1005, "id does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.tradg_vn {
			let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "tradg_vn does not match the required pattern".to_string()));
			}
		}
		self.txs_exctd.validate()?;
		self.txs_exctd_exclg_pre_trad_wvr.validate()?;
		self.txs_exctd_exclg_pst_trad_lrg_in_scale_wvr.validate()?;
		Ok(())
	}
}


// TransparencyDataReport15 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransparencyDataReport15 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechRcrdId", skip_serializing_if = "Option::is_none") )]
	pub tech_rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgDt", skip_serializing_if = "Option::is_none") )]
	pub rptg_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgVn", skip_serializing_if = "Option::is_none") )]
	pub tradg_vn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sspnsn") )]
	pub sspnsn: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbTxs", skip_serializing_if = "Option::is_none") )]
	pub nb_txs: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AggtdQttvData", skip_serializing_if = "Option::is_none") )]
	pub aggtd_qttv_data: Option<Vec<TransactionsBin2>>,
}

impl TransparencyDataReport15 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tech_rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tech_rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tech_rcrd_id exceeds the maximum length of 35".to_string()));
			}
		}
		let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
		if !pattern.is_match(&self.id) {
			return Err(ValidationError::new(1005, "id does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.tradg_vn {
			let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "tradg_vn does not match the required pattern".to_string()));
			}
		}
		if let Some(ref vec) = self.aggtd_qttv_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// TransparencyDataReport17 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransparencyDataReport17 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechRcrdId", skip_serializing_if = "Option::is_none") )]
	pub tech_rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmClssfctn", skip_serializing_if = "Option::is_none") )]
	pub fin_instrm_clssfctn: Option<EquityInstrumentReportingClassification1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FullNm", skip_serializing_if = "Option::is_none") )]
	pub full_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgVn", skip_serializing_if = "Option::is_none") )]
	pub tradg_vn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgPrd", skip_serializing_if = "Option::is_none") )]
	pub rptg_prd: Option<Period4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Lqdty", skip_serializing_if = "Option::is_none") )]
	pub lqdty: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mthdlgy", skip_serializing_if = "Option::is_none") )]
	pub mthdlgy: Option<TransparencyMethodology2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sttstcs", skip_serializing_if = "Option::is_none") )]
	pub sttstcs: Option<StatisticsTransparency3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RlvntMkt", skip_serializing_if = "Option::is_none") )]
	pub rlvnt_mkt: Option<MarketDetail2>,
}

impl TransparencyDataReport17 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tech_rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tech_rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tech_rcrd_id exceeds the maximum length of 35".to_string()));
			}
		}
		let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
		if !pattern.is_match(&self.id) {
			return Err(ValidationError::new(1005, "id does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.fin_instrm_clssfctn { val.validate()? }
		if let Some(ref val) = self.full_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "full_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "full_nm exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.tradg_vn {
			let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "tradg_vn does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.rptg_prd { val.validate()? }
		if let Some(ref val) = self.mthdlgy { val.validate()? }
		if let Some(ref val) = self.sttstcs { val.validate()? }
		if let Some(ref val) = self.rlvnt_mkt { val.validate()? }
		Ok(())
	}
}


// TransparencyDataReport20 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransparencyDataReport20 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechRcrdId", skip_serializing_if = "Option::is_none") )]
	pub tech_rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: InstrumentOrSubClassIdentification2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FullNm", skip_serializing_if = "Option::is_none") )]
	pub full_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgVn", skip_serializing_if = "Option::is_none") )]
	pub tradg_vn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgPrd", skip_serializing_if = "Option::is_none") )]
	pub rptg_prd: Option<Period4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Lqdty", skip_serializing_if = "Option::is_none") )]
	pub lqdty: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PreTradLrgInScaleThrshld", skip_serializing_if = "Option::is_none") )]
	pub pre_trad_lrg_in_scale_thrshld: Option<TonsOrCurrency2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstTradLrgInScaleThrshld", skip_serializing_if = "Option::is_none") )]
	pub pst_trad_lrg_in_scale_thrshld: Option<TonsOrCurrency2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PreTradInstrmSzSpcfcThrshld", skip_serializing_if = "Option::is_none") )]
	pub pre_trad_instrm_sz_spcfc_thrshld: Option<TonsOrCurrency2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PstTradInstrmSzSpcfcThrshld", skip_serializing_if = "Option::is_none") )]
	pub pst_trad_instrm_sz_spcfc_thrshld: Option<TonsOrCurrency2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sttstcs", skip_serializing_if = "Option::is_none") )]
	pub sttstcs: Option<StatisticsTransparency2>,
}

impl TransparencyDataReport20 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tech_rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tech_rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tech_rcrd_id exceeds the maximum length of 35".to_string()));
			}
		}
		self.id.validate()?;
		if let Some(ref val) = self.full_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "full_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "full_nm exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.tradg_vn {
			let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "tradg_vn does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.rptg_prd { val.validate()? }
		if let Some(ref val) = self.pre_trad_lrg_in_scale_thrshld { val.validate()? }
		if let Some(ref val) = self.pst_trad_lrg_in_scale_thrshld { val.validate()? }
		if let Some(ref val) = self.pre_trad_instrm_sz_spcfc_thrshld { val.validate()? }
		if let Some(ref val) = self.pst_trad_instrm_sz_spcfc_thrshld { val.validate()? }
		if let Some(ref val) = self.sttstcs { val.validate()? }
		Ok(())
	}
}


// TransparencyDataReport21 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TransparencyDataReport21 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechRcrdId", skip_serializing_if = "Option::is_none") )]
	pub tech_rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FullNm", skip_serializing_if = "Option::is_none") )]
	pub full_nm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgVn", skip_serializing_if = "Option::is_none") )]
	pub tradg_vn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgDt", skip_serializing_if = "Option::is_none") )]
	pub rptg_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MtrtyDt", skip_serializing_if = "Option::is_none") )]
	pub mtrty_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FinInstrmClssfctn") )]
	pub fin_instrm_clssfctn: NonEquityInstrumentReportingClassification1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UndrlygInstrmAsstClss", skip_serializing_if = "Option::is_none") )]
	pub undrlyg_instrm_asst_clss: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DerivCtrctTp", skip_serializing_if = "Option::is_none") )]
	pub deriv_ctrct_tp: Option<FinancialInstrumentContractType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Bd", skip_serializing_if = "Option::is_none") )]
	pub bd: Option<DebtInstrument5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EmssnAllwncTp", skip_serializing_if = "Option::is_none") )]
	pub emssn_allwnc_tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Deriv", skip_serializing_if = "Option::is_none") )]
	pub deriv: Option<Derivative3Choice>,
}

impl TransparencyDataReport21 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tech_rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tech_rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tech_rcrd_id exceeds the maximum length of 35".to_string()));
			}
		}
		let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
		if !pattern.is_match(&self.id) {
			return Err(ValidationError::new(1005, "id does not match the required pattern".to_string()));
		}
		if let Some(ref val) = self.full_nm {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "full_nm is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "full_nm exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.tradg_vn {
			let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "tradg_vn does not match the required pattern".to_string()));
			}
		}
		self.fin_instrm_clssfctn.validate()?;
		if let Some(ref val) = self.undrlyg_instrm_asst_clss {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "undrlyg_instrm_asst_clss is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "undrlyg_instrm_asst_clss exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.deriv_ctrct_tp { val.validate()? }
		if let Some(ref val) = self.bd { val.validate()? }
		if let Some(ref val) = self.emssn_allwnc_tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "emssn_allwnc_tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "emssn_allwnc_tp exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.deriv { val.validate()? }
		Ok(())
	}
}


// TransparencyMethodology2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum TransparencyMethodology2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "YEAR") )]
	CodeYEAR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SINT") )]
	CodeSINT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FFWK") )]
	CodeFFWK,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ESTM") )]
	CodeESTM,
}

impl TransparencyMethodology2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TreasuryProfile1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TreasuryProfile1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dt") )]
	pub dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradrTp") )]
	pub tradr_tp: PartyRole5Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rate") )]
	pub rate: f64,
}

impl TreasuryProfile1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tradr_tp.validate()?;
		Ok(())
	}
}


// TripartyCollateralAndAmount1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TripartyCollateralAndAmount1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Trpty") )]
	pub trpty: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CollTp") )]
	pub coll_tp: CollateralType22Choice,
}

impl TripartyCollateralAndAmount1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.trpty.validate()?;
		self.coll_tp.validate()?;
		Ok(())
	}
}


// TypeModification1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct TypeModification1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ModCd", skip_serializing_if = "Option::is_none") )]
	pub mod_cd: Option<Modification1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: CashAccountType2Choice,
}

impl TypeModification1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mod_cd { val.validate()? }
		self.tp.validate()?;
		Ok(())
	}
}


// TypeOfPrice10Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum TypeOfPrice10Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "BIDE") )]
	CodeBIDE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OFFR") )]
	CodeOFFR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NAVL") )]
	CodeNAVL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CREA") )]
	CodeCREA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CANC") )]
	CodeCANC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INTE") )]
	CodeINTE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SWNG") )]
	CodeSWNG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MIDD") )]
	CodeMIDD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RINV") )]
	CodeRINV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SWIC") )]
	CodeSWIC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DDVR") )]
	CodeDDVR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACTU") )]
	CodeACTU,
}

impl TypeOfPrice10Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TypeOfPrice1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum TypeOfPrice1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "AVER") )]
	CodeAVER,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AVOV") )]
	CodeAVOV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "COMB") )]
	CodeCOMB,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GREX") )]
	CodeGREX,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LIMI") )]
	CodeLIMI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NET2") )]
	CodeNET2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NDIS") )]
	CodeNDIS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NET1") )]
	CodeNET1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NUND") )]
	CodeNUND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NOGR") )]
	CodeNOGR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PARV") )]
	CodePARV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RDAV") )]
	CodeRDAV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "STOP") )]
	CodeSTOP,
}

impl TypeOfPrice1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TypeOfPrice6Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum TypeOfPrice6Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "BIDE") )]
	CodeBIDE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OFFR") )]
	CodeOFFR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NAVL") )]
	CodeNAVL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CREA") )]
	CodeCREA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CANC") )]
	CodeCANC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INTE") )]
	CodeINTE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SWNG") )]
	CodeSWNG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MIDD") )]
	CodeMIDD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RINV") )]
	CodeRINV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SWIC") )]
	CodeSWIC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DDVR") )]
	CodeDDVR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACTU") )]
	CodeACTU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NAUP") )]
	CodeNAUP,
}

impl TypeOfPrice6Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// TypeOfPrice9Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum TypeOfPrice9Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "BIDE") )]
	CodeBIDE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OFFR") )]
	CodeOFFR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NAVL") )]
	CodeNAVL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CREA") )]
	CodeCREA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CANC") )]
	CodeCANC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INTE") )]
	CodeINTE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SWNG") )]
	CodeSWNG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MIDD") )]
	CodeMIDD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RINV") )]
	CodeRINV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SWIC") )]
	CodeSWIC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DDVR") )]
	CodeDDVR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACTU") )]
	CodeACTU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NAUP") )]
	CodeNAUP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GUAR") )]
	CodeGUAR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ENAV") )]
	CodeENAV,
}

impl TypeOfPrice9Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// UPIQueryCriteria1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UPIQueryCriteria1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Idr", skip_serializing_if = "Option::is_none") )]
	pub idr: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NotRptd", skip_serializing_if = "Option::is_none") )]
	pub not_rptd: Option<NotReported1Code>,
}

impl UPIQueryCriteria1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.idr {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "idr is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 52 {
					return Err(ValidationError::new(1002, "idr exceeds the maximum length of 52".to_string()));
				}
			}
		}
		if let Some(ref val) = self.not_rptd { val.validate()? }
		Ok(())
	}
}


// UTCOffset1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UTCOffset1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Sgn") )]
	pub sgn: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfHrs") )]
	pub nb_of_hrs: String,
}

impl UTCOffset1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// UnableToApplyIncorrect2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UnableToApplyIncorrect2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: IncorrectData1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlIncrrctInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_incrrct_inf: Option<String>,
}

impl UnableToApplyIncorrect2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tp.validate()?;
		if let Some(ref val) = self.addtl_incrrct_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_incrrct_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "addtl_incrrct_inf exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// UnableToApplyJustification4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UnableToApplyJustification4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AnyInf", skip_serializing_if = "Option::is_none") )]
	pub any_inf: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MssngOrIncrrctInf", skip_serializing_if = "Option::is_none") )]
	pub mssng_or_incrrct_inf: Option<MissingOrIncorrectData1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PssblDplctInstr", skip_serializing_if = "Option::is_none") )]
	pub pssbl_dplct_instr: Option<bool>,
}

impl UnableToApplyJustification4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.mssng_or_incrrct_inf { val.validate()? }
		Ok(())
	}
}


// UnableToApplyMissing2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UnableToApplyMissing2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp") )]
	pub tp: MissingData1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlMssngInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_mssng_inf: Option<String>,
}

impl UnableToApplyMissing2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.tp.validate()?;
		if let Some(ref val) = self.addtl_mssng_inf {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "addtl_mssng_inf is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 140 {
				return Err(ValidationError::new(1002, "addtl_mssng_inf exceeds the maximum length of 140".to_string()));
			}
		}
		Ok(())
	}
}


// UnderlyingAttributes4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UnderlyingAttributes4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "AllcnPctg", skip_serializing_if = "Option::is_none") )]
	pub allcn_pctg: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Qty", skip_serializing_if = "Option::is_none") )]
	pub qty: Option<UnitOrFaceAmount1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmTp", skip_serializing_if = "Option::is_none") )]
	pub sttlm_tp: Option<SettlementType3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshAmt", skip_serializing_if = "Option::is_none") )]
	pub csh_amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CshTp", skip_serializing_if = "Option::is_none") )]
	pub csh_tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pric", skip_serializing_if = "Option::is_none") )]
	pub pric: Option<Price8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DrtyPric", skip_serializing_if = "Option::is_none") )]
	pub drty_pric: Option<Price8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndPric", skip_serializing_if = "Option::is_none") )]
	pub end_pric: Option<Price8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StartVal", skip_serializing_if = "Option::is_none") )]
	pub start_val: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CurVal", skip_serializing_if = "Option::is_none") )]
	pub cur_val: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndVal", skip_serializing_if = "Option::is_none") )]
	pub end_val: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AdjstdQty", skip_serializing_if = "Option::is_none") )]
	pub adjstd_qty: Option<UnitOrFaceAmount1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XchgRate", skip_serializing_if = "Option::is_none") )]
	pub xchg_rate: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CapVal", skip_serializing_if = "Option::is_none") )]
	pub cap_val: Option<ActiveCurrencyAndAmount>,
}

impl UnderlyingAttributes4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.qty { val.validate()? }
		if let Some(ref val) = self.sttlm_tp { val.validate()? }
		if let Some(ref val) = self.csh_amt { val.validate()? }
		if let Some(ref val) = self.csh_tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "csh_tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "csh_tp exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.pric { val.validate()? }
		if let Some(ref val) = self.drty_pric { val.validate()? }
		if let Some(ref val) = self.end_pric { val.validate()? }
		if let Some(ref val) = self.start_val { val.validate()? }
		if let Some(ref val) = self.cur_val { val.validate()? }
		if let Some(ref val) = self.end_val { val.validate()? }
		if let Some(ref val) = self.adjstd_qty { val.validate()? }
		if let Some(ref val) = self.cap_val { val.validate()? }
		Ok(())
	}
}


// UnderlyingContract4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UnderlyingContract4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ln", skip_serializing_if = "Option::is_none") )]
	pub ln: Option<LoanContract4>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Trad", skip_serializing_if = "Option::is_none") )]
	pub trad: Option<TradeContract4>,
}

impl UnderlyingContract4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ln { val.validate()? }
		if let Some(ref val) = self.trad { val.validate()? }
		Ok(())
	}
}


// UnderlyingContractForDifferenceType3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum UnderlyingContractForDifferenceType3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "BOND") )]
	CodeBOND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "COMM") )]
	CodeCOMM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CURR") )]
	CodeCURR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EMAL") )]
	CodeEMAL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EQUI") )]
	CodeEQUI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FTEQ") )]
	CodeFTEQ,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OPEQ") )]
	CodeOPEQ,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
}

impl UnderlyingContractForDifferenceType3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// UnderlyingData2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UnderlyingData2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Initn", skip_serializing_if = "Option::is_none") )]
	pub initn: Option<UnderlyingPaymentInstruction8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBk", skip_serializing_if = "Option::is_none") )]
	pub intr_bk: Option<UnderlyingPaymentTransaction7>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StmtNtry", skip_serializing_if = "Option::is_none") )]
	pub stmt_ntry: Option<UnderlyingStatementEntry5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Acct", skip_serializing_if = "Option::is_none") )]
	pub acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<GenericIdentification1>,
}

impl UnderlyingData2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.initn { val.validate()? }
		if let Some(ref val) = self.intr_bk { val.validate()? }
		if let Some(ref val) = self.stmt_ntry { val.validate()? }
		if let Some(ref val) = self.acct { val.validate()? }
		if let Some(ref val) = self.othr { val.validate()? }
		Ok(())
	}
}


// UnderlyingEquityType3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum UnderlyingEquityType3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "BSKT") )]
	CodeBSKT,
}

impl UnderlyingEquityType3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// UnderlyingEquityType4Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum UnderlyingEquityType4Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "STIX") )]
	CodeSTIX,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DIVI") )]
	CodeDIVI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VOLI") )]
	CodeVOLI,
}

impl UnderlyingEquityType4Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// UnderlyingEquityType5Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum UnderlyingEquityType5Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ETFS") )]
	CodeETFS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SHRS") )]
	CodeSHRS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DVSE") )]
	CodeDVSE,
}

impl UnderlyingEquityType5Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// UnderlyingEquityType6Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum UnderlyingEquityType6Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "BSKT") )]
	CodeBSKT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DIVI") )]
	CodeDIVI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ETFS") )]
	CodeETFS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OTHR") )]
	CodeOTHR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SHRS") )]
	CodeSHRS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DVSE") )]
	CodeDVSE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "STIX") )]
	CodeSTIX,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VOLI") )]
	CodeVOLI,
}

impl UnderlyingEquityType6Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// UnderlyingGroupInformation1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UnderlyingGroupInformation1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMsgId") )]
	pub orgnl_msg_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMsgNmId") )]
	pub orgnl_msg_nm_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlCreDtTm", skip_serializing_if = "Option::is_none") )]
	pub orgnl_cre_dt_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlMsgDlvryChanl", skip_serializing_if = "Option::is_none") )]
	pub orgnl_msg_dlvry_chanl: Option<String>,
}

impl UnderlyingGroupInformation1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.orgnl_msg_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "orgnl_msg_id is shorter than the minimum length of 1".to_string()));
		}
		if self.orgnl_msg_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "orgnl_msg_id exceeds the maximum length of 35".to_string()));
		}
		if self.orgnl_msg_nm_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "orgnl_msg_nm_id is shorter than the minimum length of 1".to_string()));
		}
		if self.orgnl_msg_nm_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "orgnl_msg_nm_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.orgnl_msg_dlvry_chanl {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_msg_dlvry_chanl is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_msg_dlvry_chanl exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// UnderlyingIdentification1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum UnderlyingIdentification1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "UKWN") )]
	CodeUKWN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BSKT") )]
	CodeBSKT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INDX") )]
	CodeINDX,
}

impl UnderlyingIdentification1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// UnderlyingIdentification2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UnderlyingIdentification2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Swp", skip_serializing_if = "Option::is_none") )]
	pub swp: Option<SwapLegIdentification2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<FinancialInstrumentIdentification7Choice>,
}

impl UnderlyingIdentification2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.swp { val.validate()? }
		if let Some(ref val) = self.othr { val.validate()? }
		Ok(())
	}
}


// UnderlyingInterestRateType3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum UnderlyingInterestRateType3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "BOND") )]
	CodeBOND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BNDF") )]
	CodeBNDF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INTR") )]
	CodeINTR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IFUT") )]
	CodeIFUT,
}

impl UnderlyingInterestRateType3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// UnderlyingInvestigationInstrument1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UnderlyingInvestigationInstrument1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl UnderlyingInvestigationInstrument1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// UnderlyingPaymentInstruction8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UnderlyingPaymentInstruction8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlGrpInf", skip_serializing_if = "Option::is_none") )]
	pub orgnl_grp_inf: Option<UnderlyingGroupInformation1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlPmtInfId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_pmt_inf_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlInstrId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_instr_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlEndToEndId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_end_to_end_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlUETR", skip_serializing_if = "Option::is_none") )]
	pub orgnl_uetr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlInstdAmt", skip_serializing_if = "Option::is_none") )]
	pub orgnl_instd_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdExctnDt", skip_serializing_if = "Option::is_none") )]
	pub reqd_exctn_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdColltnDt", skip_serializing_if = "Option::is_none") )]
	pub reqd_colltn_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlTxRef", skip_serializing_if = "Option::is_none") )]
	pub orgnl_tx_ref: Option<OriginalTransactionReference35>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlSvcLvl", skip_serializing_if = "Option::is_none") )]
	pub orgnl_svc_lvl: Option<ServiceLevel8Choice>,
}

impl UnderlyingPaymentInstruction8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgnl_grp_inf { val.validate()? }
		if let Some(ref val) = self.orgnl_pmt_inf_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_pmt_inf_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_pmt_inf_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_instr_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_instr_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_instr_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_end_to_end_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_end_to_end_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_end_to_end_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_uetr {
			let pattern = Regex::new("[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "orgnl_uetr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_instd_amt { val.validate()? }
		if let Some(ref val) = self.reqd_exctn_dt { val.validate()? }
		if let Some(ref val) = self.orgnl_tx_ref { val.validate()? }
		if let Some(ref val) = self.orgnl_svc_lvl { val.validate()? }
		Ok(())
	}
}


// UnderlyingPaymentInstruction9 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UnderlyingPaymentInstruction9 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlGrpInf", skip_serializing_if = "Option::is_none") )]
	pub orgnl_grp_inf: Option<UnderlyingGroupInformation1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlPmtInfId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_pmt_inf_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlInstrId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_instr_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlEndToEndId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_end_to_end_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlUETR", skip_serializing_if = "Option::is_none") )]
	pub orgnl_uetr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlInstdAmt", skip_serializing_if = "Option::is_none") )]
	pub orgnl_instd_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdExctnDt", skip_serializing_if = "Option::is_none") )]
	pub reqd_exctn_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReqdColltnDt", skip_serializing_if = "Option::is_none") )]
	pub reqd_colltn_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlTxRef", skip_serializing_if = "Option::is_none") )]
	pub orgnl_tx_ref: Option<OriginalTransactionReference42>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlSvcLvl", skip_serializing_if = "Option::is_none") )]
	pub orgnl_svc_lvl: Option<ServiceLevel8Choice>,
}

impl UnderlyingPaymentInstruction9 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgnl_grp_inf { val.validate()? }
		if let Some(ref val) = self.orgnl_pmt_inf_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_pmt_inf_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_pmt_inf_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_instr_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_instr_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_instr_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_end_to_end_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_end_to_end_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_end_to_end_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_uetr {
			let pattern = Regex::new("[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "orgnl_uetr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_instd_amt { val.validate()? }
		if let Some(ref val) = self.reqd_exctn_dt { val.validate()? }
		if let Some(ref val) = self.orgnl_tx_ref { val.validate()? }
		if let Some(ref val) = self.orgnl_svc_lvl { val.validate()? }
		Ok(())
	}
}


// UnderlyingPaymentTransaction7 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UnderlyingPaymentTransaction7 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlGrpInf", skip_serializing_if = "Option::is_none") )]
	pub orgnl_grp_inf: Option<UnderlyingGroupInformation1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlInstrId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_instr_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlEndToEndId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_end_to_end_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlTxId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlUETR", skip_serializing_if = "Option::is_none") )]
	pub orgnl_uetr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlIntrBkSttlmAmt", skip_serializing_if = "Option::is_none") )]
	pub orgnl_intr_bk_sttlm_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlIntrBkSttlmDt", skip_serializing_if = "Option::is_none") )]
	pub orgnl_intr_bk_sttlm_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlTxRef", skip_serializing_if = "Option::is_none") )]
	pub orgnl_tx_ref: Option<OriginalTransactionReference35>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlSvcLvl", skip_serializing_if = "Option::is_none") )]
	pub orgnl_svc_lvl: Option<ServiceLevel8Choice>,
}

impl UnderlyingPaymentTransaction7 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgnl_grp_inf { val.validate()? }
		if let Some(ref val) = self.orgnl_instr_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_instr_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_instr_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_end_to_end_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_end_to_end_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_end_to_end_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_uetr {
			let pattern = Regex::new("[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "orgnl_uetr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_intr_bk_sttlm_amt { val.validate()? }
		if let Some(ref val) = self.orgnl_tx_ref { val.validate()? }
		if let Some(ref val) = self.orgnl_svc_lvl { val.validate()? }
		Ok(())
	}
}


// UnderlyingPaymentTransaction8 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UnderlyingPaymentTransaction8 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlGrpInf", skip_serializing_if = "Option::is_none") )]
	pub orgnl_grp_inf: Option<UnderlyingGroupInformation1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlInstrId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_instr_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlEndToEndId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_end_to_end_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlTxId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlUETR", skip_serializing_if = "Option::is_none") )]
	pub orgnl_uetr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlIntrBkSttlmAmt", skip_serializing_if = "Option::is_none") )]
	pub orgnl_intr_bk_sttlm_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlIntrBkSttlmDt", skip_serializing_if = "Option::is_none") )]
	pub orgnl_intr_bk_sttlm_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlTxRef", skip_serializing_if = "Option::is_none") )]
	pub orgnl_tx_ref: Option<OriginalTransactionReference42>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlSvcLvl", skip_serializing_if = "Option::is_none") )]
	pub orgnl_svc_lvl: Option<ServiceLevel8Choice>,
}

impl UnderlyingPaymentTransaction8 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgnl_grp_inf { val.validate()? }
		if let Some(ref val) = self.orgnl_instr_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_instr_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_instr_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_end_to_end_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_end_to_end_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_end_to_end_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_tx_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_uetr {
			let pattern = Regex::new("[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "orgnl_uetr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_intr_bk_sttlm_amt { val.validate()? }
		if let Some(ref val) = self.orgnl_tx_ref { val.validate()? }
		if let Some(ref val) = self.orgnl_svc_lvl { val.validate()? }
		Ok(())
	}
}


// UnderlyingStatementEntry3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UnderlyingStatementEntry3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlGrpInf", skip_serializing_if = "Option::is_none") )]
	pub orgnl_grp_inf: Option<OriginalGroupInformation29>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlStmtId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_stmt_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlNtryId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_ntry_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlUETR", skip_serializing_if = "Option::is_none") )]
	pub orgnl_uetr: Option<String>,
}

impl UnderlyingStatementEntry3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgnl_grp_inf { val.validate()? }
		if let Some(ref val) = self.orgnl_stmt_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_stmt_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_stmt_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_ntry_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_ntry_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_ntry_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_uetr {
			let pattern = Regex::new("[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "orgnl_uetr does not match the required pattern".to_string()));
			}
		}
		Ok(())
	}
}


// UnderlyingStatementEntry5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UnderlyingStatementEntry5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlAcct", skip_serializing_if = "Option::is_none") )]
	pub orgnl_acct: Option<CashAccount40>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlGrpInf", skip_serializing_if = "Option::is_none") )]
	pub orgnl_grp_inf: Option<OriginalGroupInformation29>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlStmtId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_stmt_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlNtryRef", skip_serializing_if = "Option::is_none") )]
	pub orgnl_ntry_ref: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlUETR", skip_serializing_if = "Option::is_none") )]
	pub orgnl_uetr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlNtryAmt", skip_serializing_if = "Option::is_none") )]
	pub orgnl_ntry_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlNtryValDt", skip_serializing_if = "Option::is_none") )]
	pub orgnl_ntry_val_dt: Option<DateAndDateTime2Choice>,
}

impl UnderlyingStatementEntry5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgnl_acct { val.validate()? }
		if let Some(ref val) = self.orgnl_grp_inf { val.validate()? }
		if let Some(ref val) = self.orgnl_stmt_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_stmt_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_stmt_id exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_ntry_ref {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "orgnl_ntry_ref is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "orgnl_ntry_ref exceeds the maximum length of 35".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_uetr {
			let pattern = Regex::new("[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "orgnl_uetr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.orgnl_ntry_amt { val.validate()? }
		if let Some(ref val) = self.orgnl_ntry_val_dt { val.validate()? }
		Ok(())
	}
}


// UnderlyingTransaction32 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UnderlyingTransaction32 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlGrpInfAndSts", skip_serializing_if = "Option::is_none") )]
	pub orgnl_grp_inf_and_sts: Option<OriginalGroupHeader23>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlPmtInfAndSts", skip_serializing_if = "Option::is_none") )]
	pub orgnl_pmt_inf_and_sts: Option<Vec<OriginalPaymentInstruction48>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxInfAndSts", skip_serializing_if = "Option::is_none") )]
	pub tx_inf_and_sts: Option<Vec<PaymentTransaction152>>,
}

impl UnderlyingTransaction32 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgnl_grp_inf_and_sts { val.validate()? }
		if let Some(ref vec) = self.orgnl_pmt_inf_and_sts { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.tx_inf_and_sts { for item in vec { item.validate()? } }
		Ok(())
	}
}


// UnderlyingTransaction33 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UnderlyingTransaction33 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlGrpInfAndCxl", skip_serializing_if = "Option::is_none") )]
	pub orgnl_grp_inf_and_cxl: Option<OriginalGroupHeader21>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlPmtInfAndCxl", skip_serializing_if = "Option::is_none") )]
	pub orgnl_pmt_inf_and_cxl: Option<Vec<OriginalPaymentInstruction49>>,
}

impl UnderlyingTransaction33 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgnl_grp_inf_and_cxl { val.validate()? }
		if let Some(ref vec) = self.orgnl_pmt_inf_and_cxl { for item in vec { item.validate()? } }
		Ok(())
	}
}


// UnderlyingTransaction34 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UnderlyingTransaction34 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlGrpInfAndCxl", skip_serializing_if = "Option::is_none") )]
	pub orgnl_grp_inf_and_cxl: Option<OriginalGroupHeader21>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxInf", skip_serializing_if = "Option::is_none") )]
	pub tx_inf: Option<Vec<PaymentTransaction155>>,
}

impl UnderlyingTransaction34 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgnl_grp_inf_and_cxl { val.validate()? }
		if let Some(ref vec) = self.tx_inf { for item in vec { item.validate()? } }
		Ok(())
	}
}


// UnderlyingTransaction8Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UnderlyingTransaction8Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Initn", skip_serializing_if = "Option::is_none") )]
	pub initn: Option<UnderlyingPaymentInstruction9>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IntrBk", skip_serializing_if = "Option::is_none") )]
	pub intr_bk: Option<UnderlyingPaymentTransaction8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "StmtNtry", skip_serializing_if = "Option::is_none") )]
	pub stmt_ntry: Option<UnderlyingStatementEntry3>,
}

impl UnderlyingTransaction8Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.initn { val.validate()? }
		if let Some(ref val) = self.intr_bk { val.validate()? }
		if let Some(ref val) = self.stmt_ntry { val.validate()? }
		Ok(())
	}
}


// UniqueProductIdentifier1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UniqueProductIdentifier1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification175>,
}

impl UniqueProductIdentifier1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 52 {
				return Err(ValidationError::new(1002, "id exceeds the maximum length of 52".to_string()));
			}
		}
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// UniqueProductIdentifier2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UniqueProductIdentifier2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id", skip_serializing_if = "Option::is_none") )]
	pub id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification185>,
}

impl UniqueProductIdentifier2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 52 {
				return Err(ValidationError::new(1002, "id exceeds the maximum length of 52".to_string()));
			}
		}
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// UniqueTransactionIdentifier1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UniqueTransactionIdentifier1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnqTxIdr", skip_serializing_if = "Option::is_none") )]
	pub unq_tx_idr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification179>,
}

impl UniqueTransactionIdentifier1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.unq_tx_idr {
			let pattern = Regex::new("[A-Z0-9]{18}[0-9]{2}[A-Z0-9]{0,32}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "unq_tx_idr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// UniqueTransactionIdentifier2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UniqueTransactionIdentifier2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnqTxIdr", skip_serializing_if = "Option::is_none") )]
	pub unq_tx_idr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification175>,
}

impl UniqueTransactionIdentifier2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.unq_tx_idr {
			let pattern = Regex::new("[A-Z0-9]{18}[0-9]{2}[A-Z0-9]{0,32}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "unq_tx_idr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// UniqueTransactionIdentifier3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UniqueTransactionIdentifier3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnqTxIdr", skip_serializing_if = "Option::is_none") )]
	pub unq_tx_idr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification175>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NotAvlbl", skip_serializing_if = "Option::is_none") )]
	pub not_avlbl: Option<NoReasonCode>,
}

impl UniqueTransactionIdentifier3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.unq_tx_idr {
			let pattern = Regex::new("[A-Z0-9]{18}[0-9]{2}[A-Z0-9]{0,32}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "unq_tx_idr does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.prtry { val.validate()? }
		if let Some(ref val) = self.not_avlbl { val.validate()? }
		Ok(())
	}
}


// UnitOfMeasure11Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum UnitOfMeasure11Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ALOW") )]
	CodeALOW,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACCY") )]
	CodeACCY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BARL") )]
	CodeBARL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BCUF") )]
	CodeBCUF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BDFT") )]
	CodeBDFT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BUSL") )]
	CodeBUSL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CEER") )]
	CodeCEER,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CLRT") )]
	CodeCLRT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "KILO") )]
	CodeKILO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PIEC") )]
	CodePIEC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TONS") )]
	CodeTONS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "METR") )]
	CodeMETR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INCH") )]
	CodeINCH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "YARD") )]
	CodeYARD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GBGA") )]
	CodeGBGA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GRAM") )]
	CodeGRAM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CMET") )]
	CodeCMET,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SMET") )]
	CodeSMET,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FOOT") )]
	CodeFOOT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MILE") )]
	CodeMILE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SQIN") )]
	CodeSQIN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SQFO") )]
	CodeSQFO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SQMI") )]
	CodeSQMI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GBOU") )]
	CodeGBOU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "USOU") )]
	CodeUSOU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GBPI") )]
	CodeGBPI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "USPI") )]
	CodeUSPI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GBQA") )]
	CodeGBQA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "USGA") )]
	CodeUSGA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MMET") )]
	CodeMMET,
	#[cfg_attr( feature = "derive_serde", serde(rename = "KMET") )]
	CodeKMET,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SQYA") )]
	CodeSQYA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACRE") )]
	CodeACRE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ARES") )]
	CodeARES,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SMIL") )]
	CodeSMIL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SCMT") )]
	CodeSCMT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HECT") )]
	CodeHECT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SQKI") )]
	CodeSQKI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MILI") )]
	CodeMILI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CELI") )]
	CodeCELI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LITR") )]
	CodeLITR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PUND") )]
	CodePUND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CBME") )]
	CodeCBME,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DAYS") )]
	CodeDAYS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DMET") )]
	CodeDMET,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ENVC") )]
	CodeENVC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ENVO") )]
	CodeENVO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HUWG") )]
	CodeHUWG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "KWDC") )]
	CodeKWDC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "KWHO") )]
	CodeKWHO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "KWHC") )]
	CodeKWHC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "KMOC") )]
	CodeKMOC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "KWMC") )]
	CodeKWMC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "KWYC") )]
	CodeKWYC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MWDC") )]
	CodeMWDC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MWHO") )]
	CodeMWHO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MWHC") )]
	CodeMWHC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MWMC") )]
	CodeMWMC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MMOC") )]
	CodeMMOC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MWYC") )]
	CodeMWYC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TONE") )]
	CodeTONE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MIBA") )]
	CodeMIBA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MBTU") )]
	CodeMBTU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OZTR") )]
	CodeOZTR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UCWT") )]
	CodeUCWT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IPNT") )]
	CodeIPNT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PWRD") )]
	CodePWRD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DGEU") )]
	CodeDGEU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TOCD") )]
	CodeTOCD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GGEU") )]
	CodeGGEU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "USQA") )]
	CodeUSQA,
}

impl UnitOfMeasure11Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// UnitOfMeasure1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum UnitOfMeasure1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "PIEC") )]
	CodePIEC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TONS") )]
	CodeTONS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FOOT") )]
	CodeFOOT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GBGA") )]
	CodeGBGA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "USGA") )]
	CodeUSGA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GRAM") )]
	CodeGRAM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INCH") )]
	CodeINCH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "KILO") )]
	CodeKILO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PUND") )]
	CodePUND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "METR") )]
	CodeMETR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CMET") )]
	CodeCMET,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MMET") )]
	CodeMMET,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LITR") )]
	CodeLITR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CELI") )]
	CodeCELI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MILI") )]
	CodeMILI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GBOU") )]
	CodeGBOU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "USOU") )]
	CodeUSOU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GBQA") )]
	CodeGBQA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "USQA") )]
	CodeUSQA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GBPI") )]
	CodeGBPI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "USPI") )]
	CodeUSPI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MILE") )]
	CodeMILE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "KMET") )]
	CodeKMET,
	#[cfg_attr( feature = "derive_serde", serde(rename = "YARD") )]
	CodeYARD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SQKI") )]
	CodeSQKI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HECT") )]
	CodeHECT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ARES") )]
	CodeARES,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SMET") )]
	CodeSMET,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SCMT") )]
	CodeSCMT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SMIL") )]
	CodeSMIL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SQMI") )]
	CodeSQMI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SQYA") )]
	CodeSQYA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SQFO") )]
	CodeSQFO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SQIN") )]
	CodeSQIN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACRE") )]
	CodeACRE,
}

impl UnitOfMeasure1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// UnitOfMeasure5Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UnitOfMeasure5Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<UnitOfMeasure8Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification36>,
}

impl UnitOfMeasure5Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// UnitOfMeasure7Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UnitOfMeasure7Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<UnitOfMeasure9Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl UnitOfMeasure7Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// UnitOfMeasure8Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UnitOfMeasure8Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification175>,
}

impl UnitOfMeasure8Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// UnitOfMeasure8Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum UnitOfMeasure8Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "KILO") )]
	CodeKILO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "KMET") )]
	CodeKMET,
	#[cfg_attr( feature = "derive_serde", serde(rename = "KWDC") )]
	CodeKWDC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "KWHO") )]
	CodeKWHO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "KWHC") )]
	CodeKWHC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "KMOC") )]
	CodeKMOC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "KWMC") )]
	CodeKWMC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "KWYC") )]
	CodeKWYC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LITR") )]
	CodeLITR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MWDC") )]
	CodeMWDC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MWHO") )]
	CodeMWHO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MWHC") )]
	CodeMWHC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MWMC") )]
	CodeMWMC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MMOC") )]
	CodeMMOC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MWYC") )]
	CodeMWYC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "METR") )]
	CodeMETR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TONE") )]
	CodeTONE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MILE") )]
	CodeMILE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MILI") )]
	CodeMILI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MMET") )]
	CodeMMET,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MIBA") )]
	CodeMIBA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MBTU") )]
	CodeMBTU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PIEC") )]
	CodePIEC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PUND") )]
	CodePUND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PWRD") )]
	CodePWRD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SHAS") )]
	CodeSHAS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SCMT") )]
	CodeSCMT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SQFO") )]
	CodeSQFO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SQIN") )]
	CodeSQIN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SQKI") )]
	CodeSQKI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SMET") )]
	CodeSMET,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SQMI") )]
	CodeSQMI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SMIL") )]
	CodeSMIL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SQYA") )]
	CodeSQYA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "THMS") )]
	CodeTHMS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TONS") )]
	CodeTONS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TOCD") )]
	CodeTOCD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OZTR") )]
	CodeOZTR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "USGA") )]
	CodeUSGA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UCWT") )]
	CodeUCWT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "USOU") )]
	CodeUSOU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "USPI") )]
	CodeUSPI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "USQA") )]
	CodeUSQA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "YARD") )]
	CodeYARD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACRE") )]
	CodeACRE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ALOW") )]
	CodeALOW,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACCY") )]
	CodeACCY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ARES") )]
	CodeARES,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BARL") )]
	CodeBARL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BCUF") )]
	CodeBCUF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BDFT") )]
	CodeBDFT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BUSL") )]
	CodeBUSL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CELI") )]
	CodeCELI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CMET") )]
	CodeCMET,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CEER") )]
	CodeCEER,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CLRT") )]
	CodeCLRT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CBME") )]
	CodeCBME,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DAYS") )]
	CodeDAYS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DGEU") )]
	CodeDGEU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DMET") )]
	CodeDMET,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ENVC") )]
	CodeENVC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ENVO") )]
	CodeENVO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FOOT") )]
	CodeFOOT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GGEU") )]
	CodeGGEU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GBGA") )]
	CodeGBGA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GBOU") )]
	CodeGBOU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GBPI") )]
	CodeGBPI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GBQA") )]
	CodeGBQA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GRAM") )]
	CodeGRAM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HECT") )]
	CodeHECT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HUWG") )]
	CodeHUWG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INCH") )]
	CodeINCH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IPNT") )]
	CodeIPNT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FUTU") )]
	CodeFUTU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "USTN") )]
	CodeUSTN,
}

impl UnitOfMeasure8Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// UnitOfMeasure9Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum UnitOfMeasure9Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "BAGG") )]
	CodeBAGG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BALE") )]
	CodeBALE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BOTL") )]
	CodeBOTL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BOXX") )]
	CodeBOXX,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CRTN") )]
	CodeCRTN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CELI") )]
	CodeCELI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CMET") )]
	CodeCMET,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CNTR") )]
	CodeCNTR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CRAT") )]
	CodeCRAT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CBIN") )]
	CodeCBIN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CBME") )]
	CodeCBME,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CBML") )]
	CodeCBML,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PIEC") )]
	CodePIEC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FOOT") )]
	CodeFOOT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GBFO") )]
	CodeGBFO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GBGA") )]
	CodeGBGA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GBPI") )]
	CodeGBPI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GBQA") )]
	CodeGBQA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GBTN") )]
	CodeGBTN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GRAM") )]
	CodeGRAM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INCH") )]
	CodeINCH,
	#[cfg_attr( feature = "derive_serde", serde(rename = "KILO") )]
	CodeKILO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "KMET") )]
	CodeKMET,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LITR") )]
	CodeLITR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "METR") )]
	CodeMETR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TONE") )]
	CodeTONE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MILE") )]
	CodeMILE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MMET") )]
	CodeMMET,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MILI") )]
	CodeMILI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PUND") )]
	CodePUND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "USOU") )]
	CodeUSOU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SCMT") )]
	CodeSCMT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SQFO") )]
	CodeSQFO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SQIN") )]
	CodeSQIN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SQKI") )]
	CodeSQKI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SMET") )]
	CodeSMET,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SQMI") )]
	CodeSQMI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SMIL") )]
	CodeSMIL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SQYA") )]
	CodeSQYA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "USBA") )]
	CodeUSBA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "USFO") )]
	CodeUSFO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "USGA") )]
	CodeUSGA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "USPI") )]
	CodeUSPI,
	#[cfg_attr( feature = "derive_serde", serde(rename = "USQA") )]
	CodeUSQA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "USTN") )]
	CodeUSTN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "YARD") )]
	CodeYARD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GBOU") )]
	CodeGBOU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ACRE") )]
	CodeACRE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ARES") )]
	CodeARES,
	#[cfg_attr( feature = "derive_serde", serde(rename = "HECT") )]
	CodeHECT,
}

impl UnitOfMeasure9Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// UnitOrFaceAmount1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UnitOrFaceAmount1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Unit", skip_serializing_if = "Option::is_none") )]
	pub unit: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FaceAmt", skip_serializing_if = "Option::is_none") )]
	pub face_amt: Option<ActiveCurrencyAndAmount>,
}

impl UnitOrFaceAmount1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.face_amt { val.validate()? }
		Ok(())
	}
}


// UnitPrice15 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UnitPrice15 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<TypeOfPrice9Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XtndedTp", skip_serializing_if = "Option::is_none") )]
	pub xtnded_tp: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PricMtd", skip_serializing_if = "Option::is_none") )]
	pub pric_mtd: Option<PriceMethod1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValInInvstmtCcy") )]
	pub val_in_invstmt_ccy: Vec<PriceValue1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValInAltrntvCcy", skip_serializing_if = "Option::is_none") )]
	pub val_in_altrntv_ccy: Option<Vec<PriceValue1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ForExctnInd") )]
	pub for_exctn_ind: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CumDvddInd") )]
	pub cum_dvdd_ind: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClctnBsis", skip_serializing_if = "Option::is_none") )]
	pub clctn_bsis: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EstmtdPricInd") )]
	pub estmtd_pric_ind: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfDaysAcrd", skip_serializing_if = "Option::is_none") )]
	pub nb_of_days_acrd: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxblIncmPerShr", skip_serializing_if = "Option::is_none") )]
	pub taxbl_incm_per_shr: Option<ActiveOrHistoricCurrencyAnd13DecimalAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxblIncmPerShrClctd", skip_serializing_if = "Option::is_none") )]
	pub taxbl_incm_per_shr_clctd: Option<TaxableIncomePerShareCalculated2Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XtndedTaxblIncmPerShrClctd", skip_serializing_if = "Option::is_none") )]
	pub xtnded_taxbl_incm_per_shr_clctd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxblIncmPerDvdd", skip_serializing_if = "Option::is_none") )]
	pub taxbl_incm_per_dvdd: Option<ActiveOrHistoricCurrencyAnd13DecimalAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EUDvddSts", skip_serializing_if = "Option::is_none") )]
	pub eu_dvdd_sts: Option<EUDividendStatus1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XtndedEUDvddSts", skip_serializing_if = "Option::is_none") )]
	pub xtnded_eu_dvdd_sts: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ChrgDtls", skip_serializing_if = "Option::is_none") )]
	pub chrg_dtls: Option<Vec<Charge15>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxLbltyDtls", skip_serializing_if = "Option::is_none") )]
	pub tax_lblty_dtls: Option<Vec<Tax17>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TaxRfndDtls", skip_serializing_if = "Option::is_none") )]
	pub tax_rfnd_dtls: Option<Vec<Tax17>>,
}

impl UnitPrice15 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.xtnded_tp {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "xtnded_tp is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "xtnded_tp exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.pric_mtd { val.validate()? }
		for item in &self.val_in_invstmt_ccy { item.validate()? }
		if let Some(ref vec) = self.val_in_altrntv_ccy { for item in vec { item.validate()? } }
		if let Some(ref val) = self.taxbl_incm_per_shr { val.validate()? }
		if let Some(ref val) = self.taxbl_incm_per_shr_clctd { val.validate()? }
		if let Some(ref val) = self.xtnded_taxbl_incm_per_shr_clctd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "xtnded_taxbl_incm_per_shr_clctd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "xtnded_taxbl_incm_per_shr_clctd exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.taxbl_incm_per_dvdd { val.validate()? }
		if let Some(ref val) = self.eu_dvdd_sts { val.validate()? }
		if let Some(ref val) = self.xtnded_eu_dvdd_sts {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "xtnded_eu_dvdd_sts is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "xtnded_eu_dvdd_sts exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref vec) = self.chrg_dtls { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.tax_lblty_dtls { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.tax_rfnd_dtls { for item in vec { item.validate()? } }
		Ok(())
	}
}


// UnitPrice19 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UnitPrice19 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "PricTp") )]
	pub pric_tp: UnitPriceType2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val") )]
	pub val: PriceValue1,
}

impl UnitPrice19 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.pric_tp.validate()?;
		self.val.validate()?;
		Ok(())
	}
}


// UnitPriceType2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UnitPriceType2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<TypeOfPrice10Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification47>,
}

impl UnitPriceType2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// UnitsOrAmount1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UnitsOrAmount1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Unit", skip_serializing_if = "Option::is_none") )]
	pub unit: Option<f64>,
}

impl UnitsOrAmount1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.amt { val.validate()? }
		Ok(())
	}
}


// UnitsOrAmountOrPercentage1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UnitsOrAmountOrPercentage1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Amt", skip_serializing_if = "Option::is_none") )]
	pub amt: Option<ActiveCurrencyAndAmount>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Unit", skip_serializing_if = "Option::is_none") )]
	pub unit: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Pctg", skip_serializing_if = "Option::is_none") )]
	pub pctg: Option<f64>,
}

impl UnitsOrAmountOrPercentage1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.amt { val.validate()? }
		Ok(())
	}
}


// UnmatchedStatusReason1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum UnmatchedStatusReason1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CMIS") )]
	CodeCMIS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DDAT") )]
	CodeDDAT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DELN") )]
	CodeDELN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DEPT") )]
	CodeDEPT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DMON") )]
	CodeDMON,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DDEA") )]
	CodeDDEA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DQUA") )]
	CodeDQUA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CADE") )]
	CodeCADE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SETR") )]
	CodeSETR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DSEC") )]
	CodeDSEC,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VASU") )]
	CodeVASU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DTRA") )]
	CodeDTRA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RSPR") )]
	CodeRSPR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REPO") )]
	CodeREPO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CLAT") )]
	CodeCLAT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RERT") )]
	CodeRERT,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REPA") )]
	CodeREPA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REPP") )]
	CodeREPP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PHYS") )]
	CodePHYS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IIND") )]
	CodeIIND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FRAP") )]
	CodeFRAP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PLCE") )]
	CodePLCE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PODU") )]
	CodePODU,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FORF") )]
	CodeFORF,
	#[cfg_attr( feature = "derive_serde", serde(rename = "REGD") )]
	CodeREGD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RTGS") )]
	CodeRTGS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ICAG") )]
	CodeICAG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CPCA") )]
	CodeCPCA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CHAR") )]
	CodeCHAR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IEXE") )]
	CodeIEXE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NCRR") )]
	CodeNCRR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NMAS") )]
	CodeNMAS,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SAFE") )]
	CodeSAFE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DTRD") )]
	CodeDTRD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LATE") )]
	CodeLATE,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TERM") )]
	CodeTERM,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ICUS") )]
	CodeICUS,
}

impl UnmatchedStatusReason1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// UnsecuredMarketReport4Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UnsecuredMarketReport4Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "DataSetActn", skip_serializing_if = "Option::is_none") )]
	pub data_set_actn: Option<ReportPeriodActivity3Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tx", skip_serializing_if = "Option::is_none") )]
	pub tx: Option<Vec<UnsecuredMarketTransaction4>>,
}

impl UnsecuredMarketReport4Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.data_set_actn { val.validate()? }
		if let Some(ref vec) = self.tx { for item in vec { item.validate()? } }
		Ok(())
	}
}


// UnsecuredMarketTransaction4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UnsecuredMarketTransaction4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptdTxSts") )]
	pub rptd_tx_sts: TransactionOperationType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NvtnSts", skip_serializing_if = "Option::is_none") )]
	pub nvtn_sts: Option<NovationStatus1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BrnchId", skip_serializing_if = "Option::is_none") )]
	pub brnch_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UnqTxIdr", skip_serializing_if = "Option::is_none") )]
	pub unq_tx_idr: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PrtryTxId") )]
	pub prtry_tx_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RltdPrtryTxId", skip_serializing_if = "Option::is_none") )]
	pub rltd_prtry_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtyPrtryTxId", skip_serializing_if = "Option::is_none") )]
	pub ctr_pty_prtry_tx_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrPtyId") )]
	pub ctr_pty_id: CounterpartyIdentification3Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradDt") )]
	pub trad_dt: DateAndDateTimeChoice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SttlmDt") )]
	pub sttlm_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MtrtyDt") )]
	pub mtrty_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxTp") )]
	pub tx_tp: MoneyMarketTransactionType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrmTp") )]
	pub instrm_tp: FinancialInstrumentProductType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TxNmnlAmt") )]
	pub tx_nmnl_amt: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DealPric") )]
	pub deal_pric: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RateTp") )]
	pub rate_tp: InterestRateType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DealRate", skip_serializing_if = "Option::is_none") )]
	pub deal_rate: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FltgRateNote", skip_serializing_if = "Option::is_none") )]
	pub fltg_rate_note: Option<FloatingRateNote2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BrkrdDeal", skip_serializing_if = "Option::is_none") )]
	pub brkrd_deal: Option<BrokeredDeal1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CallPutOptn", skip_serializing_if = "Option::is_none") )]
	pub call_put_optn: Option<Vec<Option12>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SplmtryData", skip_serializing_if = "Option::is_none") )]
	pub splmtry_data: Option<Vec<SupplementaryData1>>,
}

impl UnsecuredMarketTransaction4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.rptd_tx_sts.validate()?;
		if let Some(ref val) = self.nvtn_sts { val.validate()? }
		if let Some(ref val) = self.brnch_id {
			let pattern = Regex::new("[A-Z0-9]{18,18}[0-9]{2,2}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "brnch_id does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.unq_tx_idr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "unq_tx_idr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 105 {
				return Err(ValidationError::new(1002, "unq_tx_idr exceeds the maximum length of 105".to_string()));
			}
		}
		if self.prtry_tx_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "prtry_tx_id is shorter than the minimum length of 1".to_string()));
		}
		if self.prtry_tx_id.chars().count() > 105 {
			return Err(ValidationError::new(1002, "prtry_tx_id exceeds the maximum length of 105".to_string()));
		}
		if let Some(ref val) = self.rltd_prtry_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "rltd_prtry_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 105 {
				return Err(ValidationError::new(1002, "rltd_prtry_tx_id exceeds the maximum length of 105".to_string()));
			}
		}
		if let Some(ref val) = self.ctr_pty_prtry_tx_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "ctr_pty_prtry_tx_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 105 {
				return Err(ValidationError::new(1002, "ctr_pty_prtry_tx_id exceeds the maximum length of 105".to_string()));
			}
		}
		self.ctr_pty_id.validate()?;
		self.trad_dt.validate()?;
		self.tx_tp.validate()?;
		self.instrm_tp.validate()?;
		self.tx_nmnl_amt.validate()?;
		self.rate_tp.validate()?;
		if let Some(ref val) = self.fltg_rate_note { val.validate()? }
		if let Some(ref val) = self.brkrd_deal { val.validate()? }
		if let Some(ref vec) = self.call_put_optn { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.splmtry_data { for item in vec { item.validate()? } }
		Ok(())
	}
}


// UpdateLogAddress2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UpdateLogAddress2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Od") )]
	pub od: PostalAddress28,
	#[cfg_attr( feature = "derive_serde", serde(rename = "New") )]
	pub new: PostalAddress28,
}

impl UpdateLogAddress2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.od.validate()?;
		self.new.validate()?;
		Ok(())
	}
}


// UpdateLogContact2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UpdateLogContact2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Od") )]
	pub od: Contact14,
	#[cfg_attr( feature = "derive_serde", serde(rename = "New") )]
	pub new: Contact14,
}

impl UpdateLogContact2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.od.validate()?;
		self.new.validate()?;
		Ok(())
	}
}


// UpdateLogDate1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UpdateLogDate1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Od") )]
	pub od: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "New") )]
	pub new: String,
}

impl UpdateLogDate1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// UpdateLogMarketSpecificAttribute1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UpdateLogMarketSpecificAttribute1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Od") )]
	pub od: MarketSpecificAttribute1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "New") )]
	pub new: MarketSpecificAttribute1,
}

impl UpdateLogMarketSpecificAttribute1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.od.validate()?;
		self.new.validate()?;
		Ok(())
	}
}


// UpdateLogPartyLockStatus1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UpdateLogPartyLockStatus1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Od") )]
	pub od: PartyLockStatus1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "New") )]
	pub new: PartyLockStatus1,
}

impl UpdateLogPartyLockStatus1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.od.validate()?;
		self.new.validate()?;
		Ok(())
	}
}


// UpdateLogPartyName1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UpdateLogPartyName1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Od") )]
	pub od: PartyName4,
	#[cfg_attr( feature = "derive_serde", serde(rename = "New") )]
	pub new: PartyName4,
}

impl UpdateLogPartyName1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.od.validate()?;
		self.new.validate()?;
		Ok(())
	}
}


// UpdateLogPartyRecord2Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UpdateLogPartyRecord2Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Adr", skip_serializing_if = "Option::is_none") )]
	pub adr: Option<UpdateLogAddress2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtctDtls", skip_serializing_if = "Option::is_none") )]
	pub ctct_dtls: Option<UpdateLogContact2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OpngDt", skip_serializing_if = "Option::is_none") )]
	pub opng_dt: Option<UpdateLogDate1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClsgDt", skip_serializing_if = "Option::is_none") )]
	pub clsg_dt: Option<UpdateLogDate1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<UpdateLogSystemPartyType1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechAdr", skip_serializing_if = "Option::is_none") )]
	pub tech_adr: Option<UpdateLogTechnicalAddress1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MktSpcfcAttr", skip_serializing_if = "Option::is_none") )]
	pub mkt_spcfc_attr: Option<UpdateLogMarketSpecificAttribute1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Nm", skip_serializing_if = "Option::is_none") )]
	pub nm: Option<UpdateLogPartyName1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ResTp", skip_serializing_if = "Option::is_none") )]
	pub res_tp: Option<UpdateLogResidenceType1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LckSts", skip_serializing_if = "Option::is_none") )]
	pub lck_sts: Option<UpdateLogPartyLockStatus1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rstrctn", skip_serializing_if = "Option::is_none") )]
	pub rstrctn: Option<UpdateLogRestriction1>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Othr", skip_serializing_if = "Option::is_none") )]
	pub othr: Option<Vec<UpdateLogProprietary1>>,
}

impl UpdateLogPartyRecord2Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.adr { val.validate()? }
		if let Some(ref val) = self.ctct_dtls { val.validate()? }
		if let Some(ref val) = self.opng_dt { val.validate()? }
		if let Some(ref val) = self.clsg_dt { val.validate()? }
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref val) = self.tech_adr { val.validate()? }
		if let Some(ref val) = self.mkt_spcfc_attr { val.validate()? }
		if let Some(ref val) = self.nm { val.validate()? }
		if let Some(ref val) = self.res_tp { val.validate()? }
		if let Some(ref val) = self.lck_sts { val.validate()? }
		if let Some(ref val) = self.rstrctn { val.validate()? }
		if let Some(ref vec) = self.othr { for item in vec { item.validate()? } }
		Ok(())
	}
}


// UpdateLogProprietary1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UpdateLogProprietary1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "FldNm") )]
	pub fld_nm: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OdFldVal") )]
	pub od_fld_val: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "NewFldVal") )]
	pub new_fld_val: String,
}

impl UpdateLogProprietary1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.fld_nm.chars().count() < 1 {
			return Err(ValidationError::new(1001, "fld_nm is shorter than the minimum length of 1".to_string()));
		}
		if self.fld_nm.chars().count() > 35 {
			return Err(ValidationError::new(1002, "fld_nm exceeds the maximum length of 35".to_string()));
		}
		if self.od_fld_val.chars().count() < 1 {
			return Err(ValidationError::new(1001, "od_fld_val is shorter than the minimum length of 1".to_string()));
		}
		if self.od_fld_val.chars().count() > 350 {
			return Err(ValidationError::new(1002, "od_fld_val exceeds the maximum length of 350".to_string()));
		}
		if self.new_fld_val.chars().count() < 1 {
			return Err(ValidationError::new(1001, "new_fld_val is shorter than the minimum length of 1".to_string()));
		}
		if self.new_fld_val.chars().count() > 350 {
			return Err(ValidationError::new(1002, "new_fld_val exceeds the maximum length of 350".to_string()));
		}
		Ok(())
	}
}


// UpdateLogResidenceType1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UpdateLogResidenceType1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Od") )]
	pub od: ResidenceType1Code,
	#[cfg_attr( feature = "derive_serde", serde(rename = "New") )]
	pub new: ResidenceType1Code,
}

impl UpdateLogResidenceType1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.od.validate()?;
		self.new.validate()?;
		Ok(())
	}
}


// UpdateLogRestriction1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UpdateLogRestriction1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Od") )]
	pub od: Restriction1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "New") )]
	pub new: Restriction1,
}

impl UpdateLogRestriction1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.od.validate()?;
		self.new.validate()?;
		Ok(())
	}
}


// UpdateLogSystemPartyType1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UpdateLogSystemPartyType1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Od") )]
	pub od: SystemPartyType1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "New") )]
	pub new: SystemPartyType1Choice,
}

impl UpdateLogSystemPartyType1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.od.validate()?;
		self.new.validate()?;
		Ok(())
	}
}


// UpdateLogTechnicalAddress1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UpdateLogTechnicalAddress1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Od") )]
	pub od: TechnicalIdentification2Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "New") )]
	pub new: TechnicalIdentification2Choice,
}

impl UpdateLogTechnicalAddress1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.od.validate()?;
		self.new.validate()?;
		Ok(())
	}
}


// UpdateType15Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UpdateType15Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<StatementUpdateType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl UpdateType15Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// UpdateType35Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UpdateType35Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Add", skip_serializing_if = "Option::is_none") )]
	pub add: Option<SecurityAttributes12>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Del", skip_serializing_if = "Option::is_none") )]
	pub del: Option<SecurityAttributes12>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Modfy", skip_serializing_if = "Option::is_none") )]
	pub modfy: Option<SecurityAttributes12>,
}

impl UpdateType35Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.add { val.validate()? }
		if let Some(ref val) = self.del { val.validate()? }
		if let Some(ref val) = self.modfy { val.validate()? }
		Ok(())
	}
}


// UpdateType36Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct UpdateType36Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "UpdTp", skip_serializing_if = "Option::is_none") )]
	pub upd_tp: Option<Vec<UpdateType35Choice>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rplc", skip_serializing_if = "Option::is_none") )]
	pub rplc: Option<SecurityAttributes12>,
}

impl UpdateType36Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref vec) = self.upd_tp { for item in vec { item.validate()? } }
		if let Some(ref val) = self.rplc { val.validate()? }
		Ok(())
	}
}


// UseCases1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum UseCases1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "OPEN") )]
	CodeOPEN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MNTN") )]
	CodeMNTN,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CLSG") )]
	CodeCLSG,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VIEW") )]
	CodeVIEW,
}

impl UseCases1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// UserInterface2Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum UserInterface2Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "MDSP") )]
	CodeMDSP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "CDSP") )]
	CodeCDSP,
}

impl UserInterface2Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ValidationRuleSchemeName1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ValidationRuleSchemeName1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl ValidationRuleSchemeName1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// ValidationStatusReason3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ValidationStatusReason3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Orgtr", skip_serializing_if = "Option::is_none") )]
	pub orgtr: Option<PartyIdentification272>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<StatusReason6Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldtnRule", skip_serializing_if = "Option::is_none") )]
	pub vldtn_rule: Option<Vec<GenericValidationRuleIdentification1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<Vec<String>>,
}

impl ValidationStatusReason3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.orgtr { val.validate()? }
		if let Some(ref val) = self.rsn { val.validate()? }
		if let Some(ref vec) = self.vldtn_rule { for item in vec { item.validate()? } }
		if let Some(ref vec) = self.addtl_inf {
			for item in vec {
				if item.chars().count() < 1 {
					return Err(ValidationError::new(1001, "addtl_inf is shorter than the minimum length of 1".to_string()));
				}
				if item.chars().count() > 105 {
					return Err(ValidationError::new(1002, "addtl_inf exceeds the maximum length of 105".to_string()));
				}
			}
		}
		Ok(())
	}
}


// ValidityPeriod1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ValidityPeriod1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "VldtyPrdCd", skip_serializing_if = "Option::is_none") )]
	pub vldty_prd_cd: Option<ValidityPeriodType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl ValidityPeriod1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.vldty_prd_cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// ValidityPeriodType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ValidityPeriodType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "FOKV") )]
	CodeFOKV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GADV") )]
	CodeGADV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GASV") )]
	CodeGASV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GATV") )]
	CodeGATV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DAVY") )]
	CodeDAVY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GTCV") )]
	CodeGTCV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GTDV") )]
	CodeGTDV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GTSV") )]
	CodeGTSV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "GTTV") )]
	CodeGTTV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IOCV") )]
	CodeIOCV,
}

impl ValidityPeriodType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ValuationDealingProcessingCharacteristics3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ValuationDealingProcessingCharacteristics3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValtnFrqcy", skip_serializing_if = "Option::is_none") )]
	pub valtn_frqcy: Option<EventFrequency5Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValtnFrqcyDesc", skip_serializing_if = "Option::is_none") )]
	pub valtn_frqcy_desc: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValtnTm", skip_serializing_if = "Option::is_none") )]
	pub valtn_tm: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DcmlstnUnits", skip_serializing_if = "Option::is_none") )]
	pub dcmlstn_units: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DcmlstnPric", skip_serializing_if = "Option::is_none") )]
	pub dcmlstn_pric: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "DualFndInd", skip_serializing_if = "Option::is_none") )]
	pub dual_fnd_ind: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PricMtd", skip_serializing_if = "Option::is_none") )]
	pub pric_mtd: Option<PriceMethod1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PricCcy", skip_serializing_if = "Option::is_none") )]
	pub pric_ccy: Option<Vec<String>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none") )]
	pub addtl_inf: Option<Vec<AdditionalInformation15>>,
}

impl ValuationDealingProcessingCharacteristics3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.valtn_frqcy { val.validate()? }
		if let Some(ref val) = self.valtn_frqcy_desc {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "valtn_frqcy_desc is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "valtn_frqcy_desc exceeds the maximum length of 350".to_string()));
			}
		}
		if let Some(ref val) = self.pric_mtd { val.validate()? }
		if let Some(ref vec) = self.pric_ccy {
			for item in vec {
				let pattern = Regex::new("[A-Z]{3,3}").unwrap();
				if !pattern.is_match(&item) {
					return Err(ValidationError::new(1005, "pric_ccy does not match the required pattern".to_string()));
				}
			}
		}
		if let Some(ref vec) = self.addtl_inf { for item in vec { item.validate()? } }
		Ok(())
	}
}


// ValuationMatchingCriteria1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ValuationMatchingCriteria1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "CtrctVal", skip_serializing_if = "Option::is_none") )]
	pub ctrct_val: Option<CompareAmountAndDirection3>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<CompareValuationType1>,
}

impl ValuationMatchingCriteria1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.ctrct_val { val.validate()? }
		if let Some(ref val) = self.tp { val.validate()? }
		Ok(())
	}
}


// ValuationStatistics3 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ValuationStatistics3 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ccy") )]
	pub ccy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PricTpChngBsis") )]
	pub pric_tp_chng_bsis: PriceType2,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PricChng") )]
	pub pric_chng: PriceValueChange1,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Yld", skip_serializing_if = "Option::is_none") )]
	pub yld: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ByPrdfndTmPrds", skip_serializing_if = "Option::is_none") )]
	pub by_prdfnd_tm_prds: Option<StatisticsByPredefinedTimePeriods2>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ByUsrDfndTmPrd", skip_serializing_if = "Option::is_none") )]
	pub by_usr_dfnd_tm_prd: Option<Vec<StatisticsByUserDefinedTimePeriod2>>,
}

impl ValuationStatistics3 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.ccy) {
			return Err(ValidationError::new(1005, "ccy does not match the required pattern".to_string()));
		}
		self.pric_tp_chng_bsis.validate()?;
		self.pric_chng.validate()?;
		if let Some(ref val) = self.by_prdfnd_tm_prds { val.validate()? }
		if let Some(ref vec) = self.by_usr_dfnd_tm_prd { for item in vec { item.validate()? } }
		Ok(())
	}
}


// ValuationTiming1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ValuationTiming1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "EXCP") )]
	CodeEXCP,
	#[cfg_attr( feature = "derive_serde", serde(rename = "USUA") )]
	CodeUSUA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "PATC") )]
	CodePATC,
}

impl ValuationTiming1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// ValuationType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum ValuationType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "CCPV") )]
	CodeCCPV,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MTMA") )]
	CodeMTMA,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MTMO") )]
	CodeMTMO,
}

impl ValuationType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// Value ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Value {
	#[cfg_attr( feature = "derive_serde", serde(rename = "BaseCcyItm") )]
	pub base_ccy_itm: ActiveOrHistoricCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AltrnCcyItm") )]
	pub altrn_ccy_itm: Vec<ActiveOrHistoricCurrencyAndAmount>,
}

impl Value {
	pub fn validate(&self) -> Result<(), ValidationError> {
		self.base_ccy_itm.validate()?;
		for item in &self.altrn_ccy_itm { item.validate()? }
		Ok(())
	}
}


// ValueForMoney1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct ValueForMoney1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "EMTDataRptgVFMUK", skip_serializing_if = "Option::is_none") )]
	pub emt_data_rptg_vfmuk: Option<EMTDataReportingVFMUKType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "AssmntOfValReqrdUdrCOLLUK", skip_serializing_if = "Option::is_none") )]
	pub assmnt_of_val_reqrd_udr_colluk: Option<AssessmentOfValueRequiredUnderCOLLUKType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OutcmOfCOLLAssmntOfValUK", skip_serializing_if = "Option::is_none") )]
	pub outcm_of_coll_assmnt_of_val_uk: Option<OutcomeOfCOLLAssessmentOfValueUKType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OutcmOfPRINValAssmntOrRvwUK", skip_serializing_if = "Option::is_none") )]
	pub outcm_of_prin_val_assmnt_or_rvw_uk: Option<OutcomeOfPRINValueAssessmentOrReviewUKType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OthrRvwRltdToValAndOrChrgsUK", skip_serializing_if = "Option::is_none") )]
	pub othr_rvw_rltd_to_val_and_or_chrgs_uk: Option<OtherReviewRelatedToValueAndOrChargesUKType1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FrthrInfUK", skip_serializing_if = "Option::is_none") )]
	pub frthr_inf_uk: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RvwDtUK", skip_serializing_if = "Option::is_none") )]
	pub rvw_dt_uk: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RvwNxtDueUK", skip_serializing_if = "Option::is_none") )]
	pub rvw_nxt_due_uk: Option<String>,
}

impl ValueForMoney1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.emt_data_rptg_vfmuk { val.validate()? }
		if let Some(ref val) = self.assmnt_of_val_reqrd_udr_colluk { val.validate()? }
		if let Some(ref val) = self.outcm_of_coll_assmnt_of_val_uk { val.validate()? }
		if let Some(ref val) = self.outcm_of_prin_val_assmnt_or_rvw_uk { val.validate()? }
		if let Some(ref val) = self.othr_rvw_rltd_to_val_and_or_chrgs_uk { val.validate()? }
		if let Some(ref val) = self.frthr_inf_uk {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "frthr_inf_uk is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "frthr_inf_uk exceeds the maximum length of 350".to_string()));
			}
		}
		Ok(())
	}
}


// VariationType1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum VariationType1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "DECR") )]
	CodeDECR,
	#[cfg_attr( feature = "derive_serde", serde(rename = "INCR") )]
	CodeINCR,
}

impl VariationType1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// VerificationReason1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct VerificationReason1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<String>,
}

impl VerificationReason1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "cd is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 4 {
				return Err(ValidationError::new(1002, "cd exceeds the maximum length of 4".to_string()));
			}
		}
		if let Some(ref val) = self.prtry {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "prtry is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "prtry exceeds the maximum length of 35".to_string()));
			}
		}
		Ok(())
	}
}


// VerificationReport5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct VerificationReport5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlId") )]
	pub orgnl_id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Vrfctn") )]
	pub vrfctn: bool,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Rsn", skip_serializing_if = "Option::is_none") )]
	pub rsn: Option<VerificationReason1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "OrgnlPtyAndAcctId", skip_serializing_if = "Option::is_none") )]
	pub orgnl_pty_and_acct_id: Option<IdentificationInformation5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "UpdtdPtyAndAcctId", skip_serializing_if = "Option::is_none") )]
	pub updtd_pty_and_acct_id: Option<IdentificationInformation5>,
}

impl VerificationReport5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if self.orgnl_id.chars().count() < 1 {
			return Err(ValidationError::new(1001, "orgnl_id is shorter than the minimum length of 1".to_string()));
		}
		if self.orgnl_id.chars().count() > 35 {
			return Err(ValidationError::new(1002, "orgnl_id exceeds the maximum length of 35".to_string()));
		}
		if let Some(ref val) = self.rsn { val.validate()? }
		if let Some(ref val) = self.orgnl_pty_and_acct_id { val.validate()? }
		if let Some(ref val) = self.updtd_pty_and_acct_id { val.validate()? }
		Ok(())
	}
}


// Visibilty1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Visibilty1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "StartDt", skip_serializing_if = "Option::is_none") )]
	pub start_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EndDt", skip_serializing_if = "Option::is_none") )]
	pub end_dt: Option<DateAndDateTime2Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LtdVsblty", skip_serializing_if = "Option::is_none") )]
	pub ltd_vsblty: Option<bool>,
}

impl Visibilty1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.start_dt { val.validate()? }
		if let Some(ref val) = self.end_dt { val.validate()? }
		Ok(())
	}
}


// VolumeCapReport1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct VolumeCapReport1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgPrd", skip_serializing_if = "Option::is_none") )]
	pub rptg_prd: Option<Period4Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgVn", skip_serializing_if = "Option::is_none") )]
	pub tradg_vn: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "InstrmRpt") )]
	pub instrm_rpt: Vec<VolumeCapReport2>,
}

impl VolumeCapReport1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.rptg_prd { val.validate()? }
		if let Some(ref val) = self.tradg_vn {
			let pattern = Regex::new("[A-Z0-9]{4,4}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "tradg_vn does not match the required pattern".to_string()));
			}
		}
		for item in &self.instrm_rpt { item.validate()? }
		Ok(())
	}
}


// VolumeCapReport2 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct VolumeCapReport2 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "TechRcrdId", skip_serializing_if = "Option::is_none") )]
	pub tech_rcrd_id: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Ccy") )]
	pub ccy: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlTradgVol") )]
	pub ttl_tradg_vol: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlRefPricTradgVol") )]
	pub ttl_ref_pric_tradg_vol: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlNgtdTxsTradgVol") )]
	pub ttl_ngtd_txs_tradg_vol: f64,
}

impl VolumeCapReport2 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.tech_rcrd_id {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "tech_rcrd_id is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 35 {
				return Err(ValidationError::new(1002, "tech_rcrd_id exceeds the maximum length of 35".to_string()));
			}
		}
		let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
		if !pattern.is_match(&self.id) {
			return Err(ValidationError::new(1005, "id does not match the required pattern".to_string()));
		}
		let pattern = Regex::new("[A-Z]{3,3}").unwrap();
		if !pattern.is_match(&self.ccy) {
			return Err(ValidationError::new(1005, "ccy does not match the required pattern".to_string()));
		}
		Ok(())
	}
}


// VolumeCapResult1 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct VolumeCapResult1 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Id") )]
	pub id: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RptgPrd") )]
	pub rptg_prd: Period4Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "LastUpdDt", skip_serializing_if = "Option::is_none") )]
	pub last_upd_dt: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TtlTradgVol") )]
	pub ttl_tradg_vol: ActiveCurrencyAndAmount,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgUdrWvrPctg") )]
	pub tradg_udr_wvr_pctg: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TradgUdrWvrBrkdwn", skip_serializing_if = "Option::is_none") )]
	pub tradg_udr_wvr_brkdwn: Option<Vec<TradingUnderWaiversPercentage1>>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Dsclmr", skip_serializing_if = "Option::is_none") )]
	pub dsclmr: Option<String>,
}

impl VolumeCapResult1 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		let pattern = Regex::new("[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}").unwrap();
		if !pattern.is_match(&self.id) {
			return Err(ValidationError::new(1005, "id does not match the required pattern".to_string()));
		}
		self.rptg_prd.validate()?;
		self.ttl_tradg_vol.validate()?;
		if let Some(ref vec) = self.tradg_udr_wvr_brkdwn { for item in vec { item.validate()? } }
		if let Some(ref val) = self.dsclmr {
			if val.chars().count() < 1 {
				return Err(ValidationError::new(1001, "dsclmr is shorter than the minimum length of 1".to_string()));
			}
			if val.chars().count() > 350 {
				return Err(ValidationError::new(1002, "dsclmr exceeds the maximum length of 350".to_string()));
			}
		}
		Ok(())
	}
}


// VolumeMetrics4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct VolumeMetrics4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "ReuseVal", skip_serializing_if = "Option::is_none") )]
	pub reuse_val: Option<ReuseValue1Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RinvstdCshAmt", skip_serializing_if = "Option::is_none") )]
	pub rinvstd_csh_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
}

impl VolumeMetrics4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.reuse_val { val.validate()? }
		if let Some(ref val) = self.rinvstd_csh_amt { val.validate()? }
		Ok(())
	}
}


// VolumeMetrics5 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct VolumeMetrics5 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "NbOfTxs", skip_serializing_if = "Option::is_none") )]
	pub nb_of_txs: Option<String>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Xpsr", skip_serializing_if = "Option::is_none") )]
	pub xpsr: Option<ExposureMetrics4>,
}

impl VolumeMetrics5 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.nb_of_txs {
			let pattern = Regex::new("[0-9]{1,15}").unwrap();
			if !pattern.is_match(val) {
				return Err(ValidationError::new(1005, "nb_of_txs does not match the required pattern".to_string()));
			}
		}
		if let Some(ref val) = self.xpsr { val.validate()? }
		Ok(())
	}
}


// VolumeMetrics6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct VolumeMetrics6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Postv", skip_serializing_if = "Option::is_none") )]
	pub postv: Option<ExposureMetrics5>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Neg", skip_serializing_if = "Option::is_none") )]
	pub neg: Option<ExposureMetrics5>,
}

impl VolumeMetrics6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.postv { val.validate()? }
		if let Some(ref val) = self.neg { val.validate()? }
		Ok(())
	}
}


// Warrant4 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct Warrant4 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Mltplr", skip_serializing_if = "Option::is_none") )]
	pub mltplr: Option<f64>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SbcptPric", skip_serializing_if = "Option::is_none") )]
	pub sbcpt_pric: Option<Price8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Tp", skip_serializing_if = "Option::is_none") )]
	pub tp: Option<WarrantStyle3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WarrtAgt", skip_serializing_if = "Option::is_none") )]
	pub warrt_agt: Option<Vec<Organisation38>>,
}

impl Warrant4 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.sbcpt_pric { val.validate()? }
		if let Some(ref val) = self.tp { val.validate()? }
		if let Some(ref vec) = self.warrt_agt { for item in vec { item.validate()? } }
		Ok(())
	}
}


// WarrantStyle1Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum WarrantStyle1Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "AMER") )]
	CodeAMER,
	#[cfg_attr( feature = "derive_serde", serde(rename = "EURO") )]
	CodeEURO,
	#[cfg_attr( feature = "derive_serde", serde(rename = "BERM") )]
	CodeBERM,
}

impl WarrantStyle1Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// WarrantStyle3Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct WarrantStyle3Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Cd", skip_serializing_if = "Option::is_none") )]
	pub cd: Option<WarrantStyle1Code>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "Prtry", skip_serializing_if = "Option::is_none") )]
	pub prtry: Option<GenericIdentification30>,
}

impl WarrantStyle3Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.cd { val.validate()? }
		if let Some(ref val) = self.prtry { val.validate()? }
		Ok(())
	}
}


// WeekDay3Code ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub enum WeekDay3Code {
	#[cfg_attr(feature = "derive_default", default)]
	#[cfg_attr( feature = "derive_serde", serde(rename = "ALLD") )]
	CodeALLD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "XBHL") )]
	CodeXBHL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "IBHL") )]
	CodeIBHL,
	#[cfg_attr( feature = "derive_serde", serde(rename = "FRID") )]
	CodeFRID,
	#[cfg_attr( feature = "derive_serde", serde(rename = "MOND") )]
	CodeMOND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SATD") )]
	CodeSATD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "SUND") )]
	CodeSUND,
	#[cfg_attr( feature = "derive_serde", serde(rename = "THUD") )]
	CodeTHUD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "TUED") )]
	CodeTUED,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WEDD") )]
	CodeWEDD,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WDAY") )]
	CodeWDAY,
	#[cfg_attr( feature = "derive_serde", serde(rename = "WEND") )]
	CodeWEND,
}

impl WeekDay3Code {
	pub fn validate(&self) -> Result<(), ValidationError> {
		Ok(())
	}
}


// YieldCalculation6 ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct YieldCalculation6 {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Val") )]
	pub val: f64,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClctnTp", skip_serializing_if = "Option::is_none") )]
	pub clctn_tp: Option<CalculationType3Choice>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "RedPric", skip_serializing_if = "Option::is_none") )]
	pub red_pric: Option<Price8>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValDt") )]
	pub val_dt: String,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValPrd") )]
	pub val_prd: DateTimePeriod1Choice,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ClctnDt") )]
	pub clctn_dt: String,
}

impl YieldCalculation6 {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.clctn_tp { val.validate()? }
		if let Some(ref val) = self.red_pric { val.validate()? }
		self.val_prd.validate()?;
		Ok(())
	}
}


// YieldedOrValueType1Choice ...
#[cfg_attr(feature = "derive_debug", derive(Debug))]
#[cfg_attr(feature = "derive_default", derive(Default))]
#[cfg_attr(feature = "derive_serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "derive_clone", derive(Clone))]
#[cfg_attr(feature = "derive_partial_eq", derive(PartialEq))]
pub struct YieldedOrValueType1Choice {
	#[cfg_attr( feature = "derive_serde", serde(rename = "Yldd", skip_serializing_if = "Option::is_none") )]
	pub yldd: Option<bool>,
	#[cfg_attr( feature = "derive_serde", serde(rename = "ValTp", skip_serializing_if = "Option::is_none") )]
	pub val_tp: Option<PriceValueType1Code>,
}

impl YieldedOrValueType1Choice {
	pub fn validate(&self) -> Result<(), ValidationError> {
		if let Some(ref val) = self.val_tp { val.validate()? }
		Ok(())
	}
}