rust_iso20022 0.1.1

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

// pub type Document = Document;
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.114.001.01")]
pub struct ClassificationType4 {
    #[yaserde(rename = "LglFrmwk")]
    #[cfg_attr(feature = "serde", serde(rename = "LglFrmwk"))]
    pub lgl_frmwk: Vec<ExternalLegalFramework1Code>,

    #[yaserde(rename = "InfTp")]
    #[cfg_attr(feature = "serde", serde(rename = "InfTp"))]
    pub inf_tp: ExternalRegulatoryInformationType1Code,
}

impl Validate for ClassificationType4 {}


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

impl Validate for CountryCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.114.001.01")]
pub struct Document {
    #[yaserde(rename = "RgltryMetadataRpt")]
    #[cfg_attr(feature = "serde", serde(rename = "RgltryMetadataRpt"))]
    pub rgltry_metadata_rpt: RegulatoryMetadataReportV01,
}

impl Validate for Document {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.114.001.01")]
pub struct Document26 {
    #[yaserde(rename = "Lang")]
    #[cfg_attr(feature = "serde", serde(rename = "Lang"))]
    pub lang: Vec<Iso2AlanguageCode>,

    #[yaserde(rename = "OrgnlOrTrnsltd")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgnlOrTrnsltd"))]
    pub orgnl_or_trnsltd: LanguageVersion1Code,

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

    #[yaserde(rename = "Ref")]
    #[cfg_attr(feature = "serde", serde(rename = "Ref"))]
    pub _ref: Max2048Text,

    #[yaserde(rename = "ElctrncSealRef")]
    #[cfg_attr(feature = "serde", serde(rename = "ElctrncSealRef"))]
    pub elctrnc_seal_ref: Max2048Text,
}

impl Validate for Document26 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.114.001.01")]
pub struct Document28 {
    #[yaserde(rename = "TechRcrdIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "TechRcrdIdr"))]
    pub tech_rcrd_idr: Max140Text,

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

    #[yaserde(rename = "SubmissnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "SubmissnTp"))]
    pub submissn_tp: TransactionOperationType13Code,

    #[yaserde(rename = "RltdNtty")]
    #[cfg_attr(feature = "serde", serde(rename = "RltdNtty"))]
    pub rltd_ntty: Vec<PartyIdentification260Choice>,

    #[yaserde(rename = "RgltryDataTp")]
    #[cfg_attr(feature = "serde", serde(rename = "RgltryDataTp"))]
    pub rgltry_data_tp: Vec<ClassificationType4>,

    #[yaserde(rename = "Vlntry")]
    #[cfg_attr(feature = "serde", serde(rename = "Vlntry"))]
    pub vlntry: TrueFalseIndicator,

    #[yaserde(rename = "HstrclData")]
    #[cfg_attr(feature = "serde", serde(rename = "HstrclData"))]
    pub hstrcl_data: TrueFalseIndicator,

    #[yaserde(rename = "RltdPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "RltdPrd"))]
    pub rltd_prd: Period4Choice,

    #[yaserde(rename = "PrsnlData")]
    #[cfg_attr(feature = "serde", serde(rename = "PrsnlData"))]
    pub prsnl_data: TrueFalseIndicator,

    #[yaserde(rename = "PblctnPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "PblctnPrd"))]
    pub pblctn_prd: Period4Choice,

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

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

    #[yaserde(rename = "HstCtry")]
    #[cfg_attr(feature = "serde", serde(rename = "HstCtry"))]
    pub hst_ctry: Vec<CountryCode>,

    #[yaserde(rename = "RltdPdctIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "RltdPdctIdr"))]
    pub rltd_pdct_idr: Vec<SecurityIdentification49>,

    #[yaserde(rename = "DocRef")]
    #[cfg_attr(feature = "serde", serde(rename = "DocRef"))]
    pub doc_ref: Vec<Document26>,

    #[yaserde(rename = "RltdRgltryData")]
    #[cfg_attr(feature = "serde", serde(rename = "RltdRgltryData"))]
    pub rltd_rgltry_data: Vec<GenericIdentification190>,

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

impl Validate for Document28 {}


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Validate for GenericIdentification175 {}


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

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

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

impl Validate for GenericIdentification185 {}


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

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

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

impl Validate for GenericIdentification190 {}


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

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

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

impl Validate for GenericOrganisationIdentification3 {}


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

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

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

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

impl Validate for IsodateTime {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.114.001.01")]
pub struct IndustrySector3Choice {
    #[yaserde(rename = "RgltryTxnmySctr")]
    #[cfg_attr(feature = "serde", serde(rename = "RgltryTxnmySctr"))]
    pub rgltry_txnmy_sctr: Option<ExternalIndustrySectorClassification1Code>,
    #[yaserde(rename = "NACETxnmySctr")]
    #[cfg_attr(feature = "serde", serde(rename = "NACETxnmySctr"))]
    pub nacetxnmy_sctr: Option<Nacedomain2025Identifier>,
}

impl Validate for IndustrySector3Choice {}




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

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

pub enum LanguageVersion1Code {
    #[yaserde(rename = "ORIG")]
    #[cfg_attr(feature = "serde", serde(rename = "ORIG"))]
    Orig,
    #[yaserde(rename = "TRAN")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAN"))]
    Tran,
    __Unknown__(String),
}

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

impl Validate for LanguageVersion1Code {}



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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.114.001.01")]
pub struct MetadataReport5 {
    #[yaserde(rename = "SubmitgNtty")]
    #[cfg_attr(feature = "serde", serde(rename = "SubmitgNtty"))]
    pub submitg_ntty: PartyIdentification260Choice,

    #[yaserde(rename = "ColltnBody")]
    #[cfg_attr(feature = "serde", serde(rename = "ColltnBody"))]
    pub colltn_body: GenericIdentification175,

    #[yaserde(rename = "RltdNtty")]
    #[cfg_attr(feature = "serde", serde(rename = "RltdNtty"))]
    pub rltd_ntty: Vec<PartyIdentification260Choice>,

    #[yaserde(rename = "RltdPdctIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "RltdPdctIdr"))]
    pub rltd_pdct_idr: Vec<SecurityIdentification49>,

    #[yaserde(rename = "RgltryDataTp")]
    #[cfg_attr(feature = "serde", serde(rename = "RgltryDataTp"))]
    pub rgltry_data_tp: Vec<ClassificationType4>,

    #[yaserde(rename = "RgltryData")]
    #[cfg_attr(feature = "serde", serde(rename = "RgltryData"))]
    pub rgltry_data: Vec<Document28>,
}

impl Validate for MetadataReport5 {}


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

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

impl Validate for Npiidentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.114.001.01")]
pub struct NaturalPersonIdentification5 {
    #[yaserde(rename = "PrsnNm")]
    #[cfg_attr(feature = "serde", serde(rename = "PrsnNm"))]
    pub prsn_nm: Vec<Max500Text>,

    #[yaserde(rename = "NPI")]
    #[cfg_attr(feature = "serde", serde(rename = "NPI"))]
    pub npi: Npiidentifier,

    #[yaserde(rename = "AltrnId")]
    #[cfg_attr(feature = "serde", serde(rename = "AltrnId"))]
    pub altrn_id: GenericIdentification175,

    #[yaserde(rename = "NttySz")]
    #[cfg_attr(feature = "serde", serde(rename = "NttySz"))]
    pub ntty_sz: ExternalEntitySize1Code,

    #[yaserde(rename = "Sctr")]
    #[cfg_attr(feature = "serde", serde(rename = "Sctr"))]
    pub sctr: Vec<IndustrySector3Choice>,

    #[yaserde(rename = "NttyTp")]
    #[cfg_attr(feature = "serde", serde(rename = "NttyTp"))]
    pub ntty_tp: ExternalEntityType1Code,
}

impl Validate for NaturalPersonIdentification5 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.114.001.01")]
pub struct OrganisationIdentification49 {
    #[yaserde(rename = "LEI")]
    #[cfg_attr(feature = "serde", serde(rename = "LEI"))]
    pub lei: Leiidentifier,

    #[yaserde(rename = "OrgNm")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgNm"))]
    pub org_nm: Vec<PartyName5>,

    #[yaserde(rename = "AltrnOrgId")]
    #[cfg_attr(feature = "serde", serde(rename = "AltrnOrgId"))]
    pub altrn_org_id: Vec<GenericOrganisationIdentification3>,

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

    #[yaserde(rename = "NttySz")]
    #[cfg_attr(feature = "serde", serde(rename = "NttySz"))]
    pub ntty_sz: ExternalEntitySize1Code,

    #[yaserde(rename = "Sctr")]
    #[cfg_attr(feature = "serde", serde(rename = "Sctr"))]
    pub sctr: Vec<IndustrySector3Choice>,

    #[yaserde(rename = "PrsnNm")]
    #[cfg_attr(feature = "serde", serde(rename = "PrsnNm"))]
    pub prsn_nm: Vec<Max500Text>,

    #[yaserde(rename = "NPI")]
    #[cfg_attr(feature = "serde", serde(rename = "NPI"))]
    pub npi: Npiidentifier,

    #[yaserde(rename = "NttyTp")]
    #[cfg_attr(feature = "serde", serde(rename = "NttyTp"))]
    pub ntty_tp: ExternalEntityType1Code,
}

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

impl Validate for OrganisationIdentificationSchemeName1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.114.001.01")]
pub struct PartyIdentification260Choice {
    #[yaserde(rename = "LglPrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "LglPrsn"))]
    pub lgl_prsn: Option<OrganisationIdentification49>,
    #[yaserde(rename = "NtrlPrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "NtrlPrsn"))]
    pub ntrl_prsn: Option<NaturalPersonIdentification5>,
}

impl Validate for PartyIdentification260Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.114.001.01")]
pub struct PartyName5 {
    #[yaserde(rename = "Val")]
    #[cfg_attr(feature = "serde", serde(rename = "Val"))]
    pub val: Max500Text,

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

    #[yaserde(rename = "Intrnl")]
    #[cfg_attr(feature = "serde", serde(rename = "Intrnl"))]
    pub intrnl: TrueFalseIndicator,
}

impl Validate for PartyName5 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.114.001.01")]
pub struct Period2 {
    #[yaserde(rename = "FrDt")]
    #[cfg_attr(feature = "serde", serde(rename = "FrDt"))]
    pub fr_dt: Isodate,

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

impl Validate for Period2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.114.001.01")]
pub struct Period4Choice {
    #[yaserde(rename = "Dt")]
    #[cfg_attr(feature = "serde", serde(rename = "Dt"))]
    pub dt: Option<Isodate>,
    #[yaserde(rename = "FrDt")]
    #[cfg_attr(feature = "serde", serde(rename = "FrDt"))]
    pub fr_dt: Option<Isodate>,
    #[yaserde(rename = "ToDt")]
    #[cfg_attr(feature = "serde", serde(rename = "ToDt"))]
    pub to_dt: Option<Isodate>,
    #[yaserde(rename = "FrDtToDt")]
    #[cfg_attr(feature = "serde", serde(rename = "FrDtToDt"))]
    pub fr_dt_to_dt: Option<Period2>,
}

impl Validate for Period4Choice {}




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

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

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.114.001.01")]
pub struct RegulatoryMetadataReportV01 {
    #[yaserde(rename = "MetadataRpt")]
    #[cfg_attr(feature = "serde", serde(rename = "MetadataRpt"))]
    pub metadata_rpt: Vec<MetadataReport5>,

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

impl Validate for RegulatoryMetadataReportV01 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.114.001.01")]
pub struct SecurityIdentification49 {
    #[yaserde(rename = "ISIN")]
    #[cfg_attr(feature = "serde", serde(rename = "ISIN"))]
    pub isin: Isinoct2015Identifier,

    #[yaserde(rename = "UnqPdctIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "UnqPdctIdr"))]
    pub unq_pdct_idr: UniqueProductIdentifier2Choice,

    #[yaserde(rename = "AltrntvInstrmId")]
    #[cfg_attr(feature = "serde", serde(rename = "AltrntvInstrmId"))]
    pub altrntv_instrm_id: GenericIdentification175,

    #[yaserde(rename = "PdctDesc")]
    #[cfg_attr(feature = "serde", serde(rename = "PdctDesc"))]
    pub pdct_desc: Max1000Text,
}

impl Validate for SecurityIdentification49 {}


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

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

impl Validate for SupplementaryData1 {}


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

impl Validate for SupplementaryDataEnvelope1 {}


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

pub enum TransactionOperationType13Code {
    #[yaserde(rename = "CORR")]
    #[cfg_attr(feature = "serde", serde(rename = "CORR"))]
    Corr,
    #[yaserde(rename = "EROR")]
    #[cfg_attr(feature = "serde", serde(rename = "EROR"))]
    Eror,
    #[yaserde(rename = "MODI")]
    #[cfg_attr(feature = "serde", serde(rename = "MODI"))]
    Modi,
    #[yaserde(rename = "NEWT")]
    #[cfg_attr(feature = "serde", serde(rename = "NEWT"))]
    Newt,
    __Unknown__(String),
}

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

impl Validate for TransactionOperationType13Code {}



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

impl Validate for TrueFalseIndicator {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.114.001.01")]
pub struct UniqueProductIdentifier2Choice {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Option<Max52Text>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification185>,
}

impl Validate for UniqueProductIdentifier2Choice {}

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