camt_028_001_09

package
v0.11.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 20, 2024 License: Apache-2.0 Imports: 3 Imported by: 0

Documentation

Overview

Code generated by GoComply XSD2Go for Moov; DO NOT EDIT. Models for urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 with prefix 'if'

Code generated by GoComply XSD2Go for Moov; DO NOT EDIT. Validations for urn:iso:std:iso:20022:tech:xsd:camt.028.001.09

Code generated by GoComply XSD2Go for Moov; DO NOT EDIT. Models for urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 with prefix 'if'

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type ActiveOrHistoricCurrencyAndAmount 

type ActiveOrHistoricCurrencyAndAmount struct {
	Value ActiveOrHistoricCurrencyAndAmountSimpleType `xml:",chardata"`
	Ccy   ActiveOrHistoricCurrencyCode                `xml:"Ccy,attr"`
}

func (ActiveOrHistoricCurrencyAndAmount) Validate 

func (v ActiveOrHistoricCurrencyAndAmount) Validate() error

type ActiveOrHistoricCurrencyAndAmountSimpleType 

type ActiveOrHistoricCurrencyAndAmountSimpleType rtp.Amount

func (ActiveOrHistoricCurrencyAndAmountSimpleType) MarshalText 

func (a ActiveOrHistoricCurrencyAndAmountSimpleType) MarshalText() ([]byte, error)

type ActiveOrHistoricCurrencyCode 

type ActiveOrHistoricCurrencyCode string
const ActiveOrHistoricCurrencyCodeUsd ActiveOrHistoricCurrencyCode = "USD"

func (ActiveOrHistoricCurrencyCode) Validate 

func (v ActiveOrHistoricCurrencyCode) Validate() error

type AdditionalPaymentInformationV09 

type AdditionalPaymentInformationV09 struct {
	Assgnmt CaseAssignment5                  `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Assgnmt"`
	Case    Case5                            `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Case"`
	Undrlyg UnderlyingTransaction5Choice     `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Undrlyg"`
	Inf     PaymentComplementaryInformation8 `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Inf"`
}

func (AdditionalPaymentInformationV09) MarshalXML 

func (v AdditionalPaymentInformationV09) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (AdditionalPaymentInformationV09) Validate 

func (v AdditionalPaymentInformationV09) Validate() error

type AdditionalPaymentInformationV09TCH 

type AdditionalPaymentInformationV09TCH struct {
	Assgnmt CaseAssignment5TCH                  `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Assgnmt"`
	Case    Case5TCH                            `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Case"`
	Undrlyg UnderlyingTransaction5ChoiceTCH     `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Undrlyg"`
	Inf     PaymentComplementaryInformation8TCH `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Inf"`
}

func (AdditionalPaymentInformationV09TCH) MarshalXML 

func (v AdditionalPaymentInformationV09TCH) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (AdditionalPaymentInformationV09TCH) Validate 

func (v AdditionalPaymentInformationV09TCH) Validate() error

type BranchAndFinancialInstitutionIdentification6 

type BranchAndFinancialInstitutionIdentification6 struct {
	FinInstnId FinancialInstitutionIdentification18 `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 FinInstnId"`
}

func (BranchAndFinancialInstitutionIdentification6) MarshalXML 

func (v BranchAndFinancialInstitutionIdentification6) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (BranchAndFinancialInstitutionIdentification6) Validate 

func (v BranchAndFinancialInstitutionIdentification6) Validate() error

type BranchAndFinancialInstitutionIdentification6TCH 

type BranchAndFinancialInstitutionIdentification6TCH struct {
	FinInstnId FinancialInstitutionIdentification18TCH `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 FinInstnId"`
}

func (BranchAndFinancialInstitutionIdentification6TCH) MarshalXML 

func (v BranchAndFinancialInstitutionIdentification6TCH) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (BranchAndFinancialInstitutionIdentification6TCH) Validate 

func (v BranchAndFinancialInstitutionIdentification6TCH) Validate() error

type Case5 

type Case5 struct {
	Id    Max35Text     `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Id"`
	Cretr Party40Choice `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Cretr"`
}

func (Case5) MarshalXML 

func (v Case5) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (Case5) Validate 

func (v Case5) Validate() error

type Case5TCH 

type Case5TCH struct {
	Id    Max35Text         `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Id"`
	Cretr Party40ChoiceTCH2 `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Cretr"`
}

func (Case5TCH) MarshalXML 

func (v Case5TCH) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (Case5TCH) Validate 

func (v Case5TCH) Validate() error

type CaseAssignment5 

type CaseAssignment5 struct {
	Id      Max35Text       `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Id"`
	Assgnr  Party40Choice   `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Assgnr"`
	Assgne  Party40Choice   `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Assgne"`
	CreDtTm rtp.ISODateTime `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 CreDtTm"`
}

func (CaseAssignment5) MarshalXML 

func (v CaseAssignment5) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (CaseAssignment5) Validate 

func (v CaseAssignment5) Validate() error

type CaseAssignment5TCH 

type CaseAssignment5TCH struct {
	Id      Max35TextTCH     `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Id"`
	Assgnr  Party40ChoiceTCH `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Assgnr"`
	Assgne  Party40ChoiceTCH `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Assgne"`
	CreDtTm rtp.ISODateTime  `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 CreDtTm"`
}

func (CaseAssignment5TCH) MarshalXML 

func (v CaseAssignment5TCH) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (CaseAssignment5TCH) Validate 

func (v CaseAssignment5TCH) Validate() error

type ClearingSystemMemberIdentification2 

type ClearingSystemMemberIdentification2 struct {
	MmbId Max35Text `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 MmbId"`
}

func (ClearingSystemMemberIdentification2) MarshalXML 

func (v ClearingSystemMemberIdentification2) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (ClearingSystemMemberIdentification2) Validate 

func (v ClearingSystemMemberIdentification2) Validate() error

type ClearingSystemMemberIdentification2TCH 

type ClearingSystemMemberIdentification2TCH struct {
	MmbId Max35TextTCH2 `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 MmbId"`
}

func (ClearingSystemMemberIdentification2TCH) MarshalXML 

func (v ClearingSystemMemberIdentification2TCH) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (ClearingSystemMemberIdentification2TCH) Validate 

func (v ClearingSystemMemberIdentification2TCH) Validate() error

type Contact4 

type Contact4 struct {
	PhneNb *PhoneNumber `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 PhneNb,omitempty"`
}

func (Contact4) MarshalXML 

func (v Contact4) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (Contact4) Validate 

func (v Contact4) Validate() error

type CountryCode 

type CountryCode string
const CountryCodeAd CountryCode = "AD"
const CountryCodeAe CountryCode = "AE"
const CountryCodeAf CountryCode = "AF"
const CountryCodeAg CountryCode = "AG"
const CountryCodeAi CountryCode = "AI"
const CountryCodeAl CountryCode = "AL"
const CountryCodeAm CountryCode = "AM"
const CountryCodeAo CountryCode = "AO"
const CountryCodeAq CountryCode = "AQ"
const CountryCodeAr CountryCode = "AR"
const CountryCodeAs CountryCode = "AS"
const CountryCodeAt CountryCode = "AT"
const CountryCodeAu CountryCode = "AU"
const CountryCodeAw CountryCode = "AW"
const CountryCodeAx CountryCode = "AX"
const CountryCodeAz CountryCode = "AZ"
const CountryCodeBa CountryCode = "BA"
const CountryCodeBb CountryCode = "BB"
const CountryCodeBd CountryCode = "BD"
const CountryCodeBe CountryCode = "BE"
const CountryCodeBf CountryCode = "BF"
const CountryCodeBg CountryCode = "BG"
const CountryCodeBh CountryCode = "BH"
const CountryCodeBi CountryCode = "BI"
const CountryCodeBj CountryCode = "BJ"
const CountryCodeBl CountryCode = "BL"
const CountryCodeBm CountryCode = "BM"
const CountryCodeBn CountryCode = "BN"
const CountryCodeBo CountryCode = "BO"
const CountryCodeBq CountryCode = "BQ"
const CountryCodeBr CountryCode = "BR"
const CountryCodeBs CountryCode = "BS"
const CountryCodeBt CountryCode = "BT"
const CountryCodeBv CountryCode = "BV"
const CountryCodeBw CountryCode = "BW"
const CountryCodeBy CountryCode = "BY"
const CountryCodeBz CountryCode = "BZ"
const CountryCodeCa CountryCode = "CA"
const CountryCodeCc CountryCode = "CC"
const CountryCodeCd CountryCode = "CD"
const CountryCodeCf CountryCode = "CF"
const CountryCodeCg CountryCode = "CG"
const CountryCodeCh CountryCode = "CH"
const CountryCodeCi CountryCode = "CI"
const CountryCodeCk CountryCode = "CK"
const CountryCodeCl CountryCode = "CL"
const CountryCodeCm CountryCode = "CM"
const CountryCodeCn CountryCode = "CN"
const CountryCodeCo CountryCode = "CO"
const CountryCodeCr CountryCode = "CR"
const CountryCodeCu CountryCode = "CU"
const CountryCodeCv CountryCode = "CV"
const CountryCodeCw CountryCode = "CW"
const CountryCodeCx CountryCode = "CX"
const CountryCodeCy CountryCode = "CY"
const CountryCodeCz CountryCode = "CZ"
const CountryCodeDe CountryCode = "DE"
const CountryCodeDj CountryCode = "DJ"
const CountryCodeDk CountryCode = "DK"
const CountryCodeDm CountryCode = "DM"
const CountryCodeDo CountryCode = "DO"
const CountryCodeDz CountryCode = "DZ"
const CountryCodeEc CountryCode = "EC"
const CountryCodeEe CountryCode = "EE"
const CountryCodeEg CountryCode = "EG"
const CountryCodeEh CountryCode = "EH"
const CountryCodeEr CountryCode = "ER"
const CountryCodeEs CountryCode = "ES"
const CountryCodeEt CountryCode = "ET"
const CountryCodeFi CountryCode = "FI"
const CountryCodeFj CountryCode = "FJ"
const CountryCodeFk CountryCode = "FK"
const CountryCodeFm CountryCode = "FM"
const CountryCodeFo CountryCode = "FO"
const CountryCodeFr CountryCode = "FR"
const CountryCodeGa CountryCode = "GA"
const CountryCodeGb CountryCode = "GB"
const CountryCodeGd CountryCode = "GD"
const CountryCodeGe CountryCode = "GE"
const CountryCodeGf CountryCode = "GF"
const CountryCodeGg CountryCode = "GG"
const CountryCodeGh CountryCode = "GH"
const CountryCodeGi CountryCode = "GI"
const CountryCodeGl CountryCode = "GL"
const CountryCodeGm CountryCode = "GM"
const CountryCodeGn CountryCode = "GN"
const CountryCodeGp CountryCode = "GP"
const CountryCodeGq CountryCode = "GQ"
const CountryCodeGr CountryCode = "GR"
const CountryCodeGs CountryCode = "GS"
const CountryCodeGt CountryCode = "GT"
const CountryCodeGu CountryCode = "GU"
const CountryCodeGw CountryCode = "GW"
const CountryCodeGy CountryCode = "GY"
const CountryCodeHk CountryCode = "HK"
const CountryCodeHm CountryCode = "HM"
const CountryCodeHn CountryCode = "HN"
const CountryCodeHr CountryCode = "HR"
const CountryCodeHt CountryCode = "HT"
const CountryCodeHu CountryCode = "HU"
const CountryCodeId CountryCode = "ID"
const CountryCodeIe CountryCode = "IE"
const CountryCodeIl CountryCode = "IL"
const CountryCodeIm CountryCode = "IM"
const CountryCodeIn CountryCode = "IN"
const CountryCodeIo CountryCode = "IO"
const CountryCodeIq CountryCode = "IQ"
const CountryCodeIr CountryCode = "IR"
const CountryCodeIs CountryCode = "IS"
const CountryCodeIt CountryCode = "IT"
const CountryCodeJe CountryCode = "JE"
const CountryCodeJm CountryCode = "JM"
const CountryCodeJo CountryCode = "JO"
const CountryCodeJp CountryCode = "JP"
const CountryCodeKe CountryCode = "KE"
const CountryCodeKg CountryCode = "KG"
const CountryCodeKh CountryCode = "KH"
const CountryCodeKi CountryCode = "KI"
const CountryCodeKm CountryCode = "KM"
const CountryCodeKn CountryCode = "KN"
const CountryCodeKp CountryCode = "KP"
const CountryCodeKr CountryCode = "KR"
const CountryCodeKw CountryCode = "KW"
const CountryCodeKy CountryCode = "KY"
const CountryCodeKz CountryCode = "KZ"
const CountryCodeLa CountryCode = "LA"
const CountryCodeLb CountryCode = "LB"
const CountryCodeLc CountryCode = "LC"
const CountryCodeLi CountryCode = "LI"
const CountryCodeLk CountryCode = "LK"
const CountryCodeLr CountryCode = "LR"
const CountryCodeLs CountryCode = "LS"
const CountryCodeLt CountryCode = "LT"
const CountryCodeLu CountryCode = "LU"
const CountryCodeLv CountryCode = "LV"
const CountryCodeLy CountryCode = "LY"
const CountryCodeMa CountryCode = "MA"
const CountryCodeMc CountryCode = "MC"
const CountryCodeMd CountryCode = "MD"
const CountryCodeMe CountryCode = "ME"
const CountryCodeMf CountryCode = "MF"
const CountryCodeMg CountryCode = "MG"
const CountryCodeMh CountryCode = "MH"
const CountryCodeMk CountryCode = "MK"
const CountryCodeMl CountryCode = "ML"
const CountryCodeMm CountryCode = "MM"
const CountryCodeMn CountryCode = "MN"
const CountryCodeMo CountryCode = "MO"
const CountryCodeMp CountryCode = "MP"
const CountryCodeMq CountryCode = "MQ"
const CountryCodeMr CountryCode = "MR"
const CountryCodeMs CountryCode = "MS"
const CountryCodeMt CountryCode = "MT"
const CountryCodeMu CountryCode = "MU"
const CountryCodeMv CountryCode = "MV"
const CountryCodeMw CountryCode = "MW"
const CountryCodeMx CountryCode = "MX"
const CountryCodeMy CountryCode = "MY"
const CountryCodeMz CountryCode = "MZ"
const CountryCodeNa CountryCode = "NA"
const CountryCodeNc CountryCode = "NC"
const CountryCodeNe CountryCode = "NE"
const CountryCodeNf CountryCode = "NF"
const CountryCodeNg CountryCode = "NG"
const CountryCodeNi CountryCode = "NI"
const CountryCodeNl CountryCode = "NL"
const CountryCodeNo CountryCode = "NO"
const CountryCodeNp CountryCode = "NP"
const CountryCodeNr CountryCode = "NR"
const CountryCodeNu CountryCode = "NU"
const CountryCodeNz CountryCode = "NZ"
const CountryCodeOm CountryCode = "OM"
const CountryCodePa CountryCode = "PA"
const CountryCodePe CountryCode = "PE"
const CountryCodePf CountryCode = "PF"
const CountryCodePg CountryCode = "PG"
const CountryCodePh CountryCode = "PH"
const CountryCodePk CountryCode = "PK"
const CountryCodePl CountryCode = "PL"
const CountryCodePm CountryCode = "PM"
const CountryCodePn CountryCode = "PN"
const CountryCodePr CountryCode = "PR"
const CountryCodePs CountryCode = "PS"
const CountryCodePt CountryCode = "PT"
const CountryCodePw CountryCode = "PW"
const CountryCodePy CountryCode = "PY"
const CountryCodeQa CountryCode = "QA"
const CountryCodeRe CountryCode = "RE"
const CountryCodeRo CountryCode = "RO"
const CountryCodeRs CountryCode = "RS"
const CountryCodeRu CountryCode = "RU"
const CountryCodeRw CountryCode = "RW"
const CountryCodeSa CountryCode = "SA"
const CountryCodeSb CountryCode = "SB"
const CountryCodeSc CountryCode = "SC"
const CountryCodeSd CountryCode = "SD"
const CountryCodeSe CountryCode = "SE"
const CountryCodeSg CountryCode = "SG"
const CountryCodeSh CountryCode = "SH"
const CountryCodeSi CountryCode = "SI"
const CountryCodeSj CountryCode = "SJ"
const CountryCodeSk CountryCode = "SK"
const CountryCodeSl CountryCode = "SL"
const CountryCodeSm CountryCode = "SM"
const CountryCodeSn CountryCode = "SN"
const CountryCodeSo CountryCode = "SO"
const CountryCodeSr CountryCode = "SR"
const CountryCodeSs CountryCode = "SS"
const CountryCodeSt CountryCode = "ST"
const CountryCodeSv CountryCode = "SV"
const CountryCodeSx CountryCode = "SX"
const CountryCodeSy CountryCode = "SY"
const CountryCodeSz CountryCode = "SZ"
const CountryCodeTc CountryCode = "TC"
const CountryCodeTd CountryCode = "TD"
const CountryCodeTf CountryCode = "TF"
const CountryCodeTg CountryCode = "TG"
const CountryCodeTh CountryCode = "TH"
const CountryCodeTj CountryCode = "TJ"
const CountryCodeTk CountryCode = "TK"
const CountryCodeTl CountryCode = "TL"
const CountryCodeTm CountryCode = "TM"
const CountryCodeTn CountryCode = "TN"
const CountryCodeTo CountryCode = "TO"
const CountryCodeTr CountryCode = "TR"
const CountryCodeTt CountryCode = "TT"
const CountryCodeTv CountryCode = "TV"
const CountryCodeTw CountryCode = "TW"
const CountryCodeTz CountryCode = "TZ"
const CountryCodeUa CountryCode = "UA"
const CountryCodeUg CountryCode = "UG"
const CountryCodeUm CountryCode = "UM"
const CountryCodeUs CountryCode = "US"
const CountryCodeUy CountryCode = "UY"
const CountryCodeUz CountryCode = "UZ"
const CountryCodeVa CountryCode = "VA"
const CountryCodeVc CountryCode = "VC"
const CountryCodeVe CountryCode = "VE"
const CountryCodeVg CountryCode = "VG"
const CountryCodeVi CountryCode = "VI"
const CountryCodeVn CountryCode = "VN"
const CountryCodeVu CountryCode = "VU"
const CountryCodeWf CountryCode = "WF"
const CountryCodeWs CountryCode = "WS"
const CountryCodeYe CountryCode = "YE"
const CountryCodeYt CountryCode = "YT"
const CountryCodeZa CountryCode = "ZA"
const CountryCodeZm CountryCode = "ZM"
const CountryCodeZw CountryCode = "ZW"

func (CountryCode) Validate 

func (v CountryCode) Validate() error

type DateAndDateTime2Choice 

type DateAndDateTime2Choice struct {
	Dt   *rtp.ISODate     `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Dt,omitempty"`
	DtTm *rtp.ISODateTime `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 DtTm,omitempty"`
}

func (DateAndDateTime2Choice) MarshalXML 

func (v DateAndDateTime2Choice) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (DateAndDateTime2Choice) Validate 

func (v DateAndDateTime2Choice) Validate() error

type DateAndPlaceOfBirth1 

type DateAndPlaceOfBirth1 struct {
	BirthDt     rtp.ISODate `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 BirthDt"`
	CityOfBirth Max35Text   `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 CityOfBirth"`
	CtryOfBirth CountryCode `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 CtryOfBirth"`
}

func (DateAndPlaceOfBirth1) MarshalXML 

func (v DateAndPlaceOfBirth1) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (DateAndPlaceOfBirth1) Validate 

func (v DateAndPlaceOfBirth1) Validate() error

type DiscountAmountAndType1 

type DiscountAmountAndType1 struct {
	Tp  DiscountAmountType1Choice         `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Tp"`
	Amt ActiveOrHistoricCurrencyAndAmount `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Amt"`
}

func (DiscountAmountAndType1) MarshalXML 

func (v DiscountAmountAndType1) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (DiscountAmountAndType1) Validate 

func (v DiscountAmountAndType1) Validate() error

type DiscountAmountAndType1TCH 

type DiscountAmountAndType1TCH struct {
	Tp  DiscountAmountType1ChoiceTCH      `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Tp"`
	Amt ActiveOrHistoricCurrencyAndAmount `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Amt"`
}

func (DiscountAmountAndType1TCH) MarshalXML 

func (v DiscountAmountAndType1TCH) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (DiscountAmountAndType1TCH) Validate 

func (v DiscountAmountAndType1TCH) Validate() error

type DiscountAmountType1Choice 

type DiscountAmountType1Choice struct {
	Prtry *Max35Text `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Prtry,omitempty"`
}

func (DiscountAmountType1Choice) MarshalXML 

func (v DiscountAmountType1Choice) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (DiscountAmountType1Choice) Validate 

func (v DiscountAmountType1Choice) Validate() error

type DiscountAmountType1ChoiceTCH 

type DiscountAmountType1ChoiceTCH struct {
	Prtry *Max35TextTCH3 `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Prtry,omitempty"`
}

func (DiscountAmountType1ChoiceTCH) MarshalXML 

func (v DiscountAmountType1ChoiceTCH) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (DiscountAmountType1ChoiceTCH) Validate 

func (v DiscountAmountType1ChoiceTCH) Validate() error

type DocumentTCH 

type DocumentTCH struct {
	XMLName     xml.Name
	AddtlPmtInf AdditionalPaymentInformationV09TCH `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 AddtlPmtInf"`
}

func (DocumentTCH) MarshalXML 

func (v DocumentTCH) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (DocumentTCH) Validate 

func (v DocumentTCH) Validate() error

type FinancialInstitutionIdentification18 

type FinancialInstitutionIdentification18 struct {
	ClrSysMmbId ClearingSystemMemberIdentification2 `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 ClrSysMmbId"`
}

func (FinancialInstitutionIdentification18) MarshalXML 

func (v FinancialInstitutionIdentification18) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (FinancialInstitutionIdentification18) Validate 

func (v FinancialInstitutionIdentification18) Validate() error

type FinancialInstitutionIdentification18TCH 

type FinancialInstitutionIdentification18TCH struct {
	ClrSysMmbId ClearingSystemMemberIdentification2TCH `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 ClrSysMmbId"`
}

func (FinancialInstitutionIdentification18TCH) MarshalXML 

func (v FinancialInstitutionIdentification18TCH) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (FinancialInstitutionIdentification18TCH) Validate 

func (v FinancialInstitutionIdentification18TCH) Validate() error

type GenericOrganisationIdentification1 

type GenericOrganisationIdentification1 struct {
	Id      Max35Text                                    `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Id"`
	SchmeNm *OrganisationIdentificationSchemeName1Choice `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 SchmeNm,omitempty"`
}

func (GenericOrganisationIdentification1) MarshalXML 

func (v GenericOrganisationIdentification1) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (GenericOrganisationIdentification1) Validate 

func (v GenericOrganisationIdentification1) Validate() error

type GenericOrganisationIdentification1TCH 

type GenericOrganisationIdentification1TCH struct {
	Id      Max35Text                                       `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Id"`
	SchmeNm *OrganisationIdentificationSchemeName1ChoiceTCH `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 SchmeNm,omitempty"`
}

func (GenericOrganisationIdentification1TCH) MarshalXML 

func (v GenericOrganisationIdentification1TCH) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (GenericOrganisationIdentification1TCH) Validate 

func (v GenericOrganisationIdentification1TCH) Validate() error

type GenericPersonIdentification1 

type GenericPersonIdentification1 struct {
	Id      Max35Text                              `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Id"`
	SchmeNm *PersonIdentificationSchemeName1Choice `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 SchmeNm,omitempty"`
}

func (GenericPersonIdentification1) MarshalXML 

func (v GenericPersonIdentification1) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (GenericPersonIdentification1) Validate 

func (v GenericPersonIdentification1) Validate() error

type LEIIdentifier 

type LEIIdentifier string

func (LEIIdentifier) Validate 

func (v LEIIdentifier) Validate() error

type Max140Text 

type Max140Text string

func (Max140Text) Validate 

func (v Max140Text) Validate() error

type Max16Text 

type Max16Text string

func (Max16Text) Validate 

func (v Max16Text) Validate() error

type Max35Text 

type Max35Text string

func (Max35Text) Validate 

func (v Max35Text) Validate() error

type Max35TextTCH 

type Max35TextTCH string

func (Max35TextTCH) Validate 

func (v Max35TextTCH) Validate() error

type Max35TextTCH2 

type Max35TextTCH2 string

func (Max35TextTCH2) Validate 

func (v Max35TextTCH2) Validate() error

type Max35TextTCH3 

type Max35TextTCH3 string
const Max35TextTCH3Dsct Max35TextTCH3 = "DSCT"
const Max35TextTCH3Full Max35TextTCH3 = "FULL"
const Max35TextTCH3Orig Max35TextTCH3 = "ORIG"

func (Max35TextTCH3) Validate 

func (v Max35TextTCH3) Validate() error

type Max70Text 

type Max70Text string

func (Max70Text) Validate 

func (v Max70Text) Validate() error

type OrganisationIdentification29 

type OrganisationIdentification29 struct {
	LEI *LEIIdentifier `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 LEI,omitempty"`
}

func (OrganisationIdentification29) MarshalXML 

func (v OrganisationIdentification29) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (OrganisationIdentification29) Validate 

func (v OrganisationIdentification29) Validate() error

type OrganisationIdentification29TCH 

type OrganisationIdentification29TCH struct {
	LEI LEIIdentifier `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 LEI"`
}

func (OrganisationIdentification29TCH) MarshalXML 

func (v OrganisationIdentification29TCH) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (OrganisationIdentification29TCH) Validate 

func (v OrganisationIdentification29TCH) Validate() error

type OrganisationIdentification30 

type OrganisationIdentification30 struct {
	LEI  *LEIIdentifier                        `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 LEI,omitempty"`
	Othr []*GenericOrganisationIdentification1 `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Othr,omitempty"`
}

func (OrganisationIdentification30) MarshalXML 

func (v OrganisationIdentification30) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (OrganisationIdentification30) Validate 

func (v OrganisationIdentification30) Validate() error

type OrganisationIdentification30TCH 

type OrganisationIdentification30TCH struct {
	LEI  *LEIIdentifier                           `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 LEI,omitempty"`
	Othr []*GenericOrganisationIdentification1TCH `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Othr,omitempty"`
}

func (OrganisationIdentification30TCH) MarshalXML 

func (v OrganisationIdentification30TCH) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (OrganisationIdentification30TCH) Validate 

func (v OrganisationIdentification30TCH) Validate() error

type OrganisationIdentificationSchemeName1Choice 

type OrganisationIdentificationSchemeName1Choice struct {
	Prtry *Max35Text `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Prtry,omitempty"`
}

func (OrganisationIdentificationSchemeName1Choice) MarshalXML 

func (v OrganisationIdentificationSchemeName1Choice) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (OrganisationIdentificationSchemeName1Choice) Validate 

func (v OrganisationIdentificationSchemeName1Choice) Validate() error

type OrganisationIdentificationSchemeName1ChoiceTCH 

type OrganisationIdentificationSchemeName1ChoiceTCH struct {
	Prtry *Max35Text `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Prtry,omitempty"`
}

func (OrganisationIdentificationSchemeName1ChoiceTCH) MarshalXML 

func (v OrganisationIdentificationSchemeName1ChoiceTCH) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (OrganisationIdentificationSchemeName1ChoiceTCH) Validate 

func (v OrganisationIdentificationSchemeName1ChoiceTCH) Validate() error

type OrigMsgName 

type OrigMsgName string
const OrigMsgNamePacs00800106 OrigMsgName = "pacs.008.001.06"
const OrigMsgNamePacs00800108 OrigMsgName = "pacs.008.001.08"
const OrigMsgNamePain01300107 OrigMsgName = "pain.013.001.07"

func (OrigMsgName) Validate 

func (v OrigMsgName) Validate() error

type OrigMsgNameTCH 

type OrigMsgNameTCH string
const OrigMsgNameTCHPain01300107 OrigMsgNameTCH = "pain.013.001.07"

func (OrigMsgNameTCH) Validate 

func (v OrigMsgNameTCH) Validate() error

type OrigMsgNameTCH2 

type OrigMsgNameTCH2 string
const OrigMsgNameTCH2Pacs00800106 OrigMsgNameTCH2 = "pacs.008.001.06"
const OrigMsgNameTCH2Pacs00800108 OrigMsgNameTCH2 = "pacs.008.001.08"

func (OrigMsgNameTCH2) Validate 

func (v OrigMsgNameTCH2) Validate() error

type Party38Choice 

type Party38Choice struct {
	OrgId  *OrganisationIdentification30 `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 OrgId,omitempty"`
	PrvtId *PersonIdentification13       `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 PrvtId,omitempty"`
}

func (Party38Choice) MarshalXML 

func (v Party38Choice) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (Party38Choice) Validate 

func (v Party38Choice) Validate() error

type Party38ChoiceTCH 

type Party38ChoiceTCH struct {
	OrgId  *OrganisationIdentification30TCH `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 OrgId,omitempty"`
	PrvtId *PersonIdentification13TCH       `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 PrvtId,omitempty"`
}

func (Party38ChoiceTCH) MarshalXML 

func (v Party38ChoiceTCH) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (Party38ChoiceTCH) Validate 

func (v Party38ChoiceTCH) Validate() error

type Party38ChoiceTCH2 

type Party38ChoiceTCH2 struct {
	OrgId  *OrganisationIdentification29TCH `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 OrgId,omitempty"`
	PrvtId *PersonIdentification13TCH2      `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 PrvtId,omitempty"`
}

func (Party38ChoiceTCH2) MarshalXML 

func (v Party38ChoiceTCH2) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (Party38ChoiceTCH2) Validate 

func (v Party38ChoiceTCH2) Validate() error

type Party38ChoiceTCH3 

type Party38ChoiceTCH3 struct {
	OrgId  *OrganisationIdentification29TCH `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 OrgId,omitempty"`
	PrvtId *PersonIdentification13TCH2      `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 PrvtId,omitempty"`
}

func (Party38ChoiceTCH3) MarshalXML 

func (v Party38ChoiceTCH3) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (Party38ChoiceTCH3) Validate 

func (v Party38ChoiceTCH3) Validate() error

type Party38ChoiceTCH4 

type Party38ChoiceTCH4 struct {
	OrgId  *OrganisationIdentification29TCH `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 OrgId,omitempty"`
	PrvtId *PersonIdentification13TCH3      `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 PrvtId,omitempty"`
}

func (Party38ChoiceTCH4) MarshalXML 

func (v Party38ChoiceTCH4) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (Party38ChoiceTCH4) Validate 

func (v Party38ChoiceTCH4) Validate() error

type Party40Choice 

type Party40Choice struct {
	Pty *PartyIdentification135                       `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Pty,omitempty"`
	Agt *BranchAndFinancialInstitutionIdentification6 `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Agt,omitempty"`
}

func (Party40Choice) MarshalXML 

func (v Party40Choice) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (Party40Choice) Validate 

func (v Party40Choice) Validate() error

type Party40ChoiceTCH 

type Party40ChoiceTCH struct {
	Agt *BranchAndFinancialInstitutionIdentification6TCH `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Agt,omitempty"`
}

func (Party40ChoiceTCH) MarshalXML 

func (v Party40ChoiceTCH) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (Party40ChoiceTCH) Validate 

func (v Party40ChoiceTCH) Validate() error

type Party40ChoiceTCH2 

type Party40ChoiceTCH2 struct {
	Pty *PartyIdentification135TCH                       `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Pty,omitempty"`
	Agt *BranchAndFinancialInstitutionIdentification6TCH `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Agt,omitempty"`
}

func (Party40ChoiceTCH2) MarshalXML 

func (v Party40ChoiceTCH2) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (Party40ChoiceTCH2) Validate 

func (v Party40ChoiceTCH2) Validate() error

type PartyIdentification135 

type PartyIdentification135 struct {
	Nm       *Max140Text      `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Nm,omitempty"`
	PstlAdr  *PostalAddress24 `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 PstlAdr,omitempty"`
	Id       *Party38Choice   `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Id,omitempty"`
	CtctDtls *Contact4        `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 CtctDtls,omitempty"`
}

func (PartyIdentification135) MarshalXML 

func (v PartyIdentification135) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (PartyIdentification135) Validate 

func (v PartyIdentification135) Validate() error

type PartyIdentification135TCH 

type PartyIdentification135TCH struct {
	Nm Max140Text `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Nm"`
}

func (PartyIdentification135TCH) MarshalXML 

func (v PartyIdentification135TCH) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (PartyIdentification135TCH) Validate 

func (v PartyIdentification135TCH) Validate() error

type PartyIdentification135TCH2 

type PartyIdentification135TCH2 struct {
	Nm      *Max140Text         `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Nm,omitempty"`
	PstlAdr *PostalAddress24TCH `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 PstlAdr,omitempty"`
	Id      *Party38ChoiceTCH   `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Id,omitempty"`
}

func (PartyIdentification135TCH2) MarshalXML 

func (v PartyIdentification135TCH2) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (PartyIdentification135TCH2) Validate 

func (v PartyIdentification135TCH2) Validate() error

type PartyIdentification135TCH3 

type PartyIdentification135TCH3 struct {
	Nm      *Max140Text         `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Nm,omitempty"`
	PstlAdr *PostalAddress24TCH `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 PstlAdr,omitempty"`
	Id      *Party38ChoiceTCH2  `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Id,omitempty"`
}

func (PartyIdentification135TCH3) MarshalXML 

func (v PartyIdentification135TCH3) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (PartyIdentification135TCH3) Validate 

func (v PartyIdentification135TCH3) Validate() error

type PartyIdentification135TCH4 

type PartyIdentification135TCH4 struct {
	Nm       *Max140Text         `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Nm,omitempty"`
	PstlAdr  *PostalAddress24TCH `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 PstlAdr,omitempty"`
	Id       *Party38ChoiceTCH3  `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Id,omitempty"`
	CtctDtls *Contact4           `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 CtctDtls,omitempty"`
}

func (PartyIdentification135TCH4) MarshalXML 

func (v PartyIdentification135TCH4) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (PartyIdentification135TCH4) Validate 

func (v PartyIdentification135TCH4) Validate() error

type PartyIdentification135TCH5 

type PartyIdentification135TCH5 struct {
	Nm      *Max140Text         `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Nm,omitempty"`
	PstlAdr *PostalAddress24TCH `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 PstlAdr,omitempty"`
	Id      *Party38ChoiceTCH4  `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Id,omitempty"`
}

func (PartyIdentification135TCH5) MarshalXML 

func (v PartyIdentification135TCH5) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (PartyIdentification135TCH5) Validate 

func (v PartyIdentification135TCH5) Validate() error

type PaymentComplementaryInformation8 

type PaymentComplementaryInformation8 struct {
	InstrId    *Max35Text               `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 InstrId,omitempty"`
	EndToEndId *Max35Text               `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 EndToEndId,omitempty"`
	TxId       *Max35Text               `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 TxId,omitempty"`
	UltmtDbtr  *PartyIdentification135  `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 UltmtDbtr,omitempty"`
	Dbtr       *PartyIdentification135  `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Dbtr,omitempty"`
	Cdtr       *PartyIdentification135  `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Cdtr,omitempty"`
	UltmtCdtr  *PartyIdentification135  `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 UltmtCdtr,omitempty"`
	RmtInf     *RemittanceInformation16 `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 RmtInf,omitempty"`
}

func (PaymentComplementaryInformation8) MarshalXML 

func (v PaymentComplementaryInformation8) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (PaymentComplementaryInformation8) Validate 

func (v PaymentComplementaryInformation8) Validate() error

type PaymentComplementaryInformation8TCH 

type PaymentComplementaryInformation8TCH struct {
	InstrId    *Max35Text                  `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 InstrId,omitempty"`
	EndToEndId *Max35Text                  `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 EndToEndId,omitempty"`
	TxId       *Max35Text                  `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 TxId,omitempty"`
	UltmtDbtr  *PartyIdentification135TCH2 `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 UltmtDbtr,omitempty"`
	Dbtr       *PartyIdentification135TCH3 `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Dbtr,omitempty"`
	Cdtr       *PartyIdentification135TCH4 `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Cdtr,omitempty"`
	UltmtCdtr  *PartyIdentification135TCH2 `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 UltmtCdtr,omitempty"`
	RmtInf     *RemittanceInformation16TCH `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 RmtInf,omitempty"`
}

func (PaymentComplementaryInformation8TCH) MarshalXML 

func (v PaymentComplementaryInformation8TCH) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (PaymentComplementaryInformation8TCH) Validate 

func (v PaymentComplementaryInformation8TCH) Validate() error

type PersonIdentification13 

type PersonIdentification13 struct {
	DtAndPlcOfBirth *DateAndPlaceOfBirth1           `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 DtAndPlcOfBirth,omitempty"`
	Othr            []*GenericPersonIdentification1 `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Othr,omitempty"`
}

func (PersonIdentification13) MarshalXML 

func (v PersonIdentification13) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (PersonIdentification13) Validate 

func (v PersonIdentification13) Validate() error

type PersonIdentification13TCH 

type PersonIdentification13TCH struct {
	DtAndPlcOfBirth *DateAndPlaceOfBirth1           `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 DtAndPlcOfBirth,omitempty"`
	Othr            []*GenericPersonIdentification1 `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Othr,omitempty"`
}

func (PersonIdentification13TCH) MarshalXML 

func (v PersonIdentification13TCH) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (PersonIdentification13TCH) Validate 

func (v PersonIdentification13TCH) Validate() error

type PersonIdentification13TCH2 

type PersonIdentification13TCH2 struct {
	DtAndPlcOfBirth DateAndPlaceOfBirth1 `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 DtAndPlcOfBirth"`
}

func (PersonIdentification13TCH2) MarshalXML 

func (v PersonIdentification13TCH2) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (PersonIdentification13TCH2) Validate 

func (v PersonIdentification13TCH2) Validate() error

type PersonIdentification13TCH3 

type PersonIdentification13TCH3 struct {
	Othr GenericPersonIdentification1 `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Othr"`
}

func (PersonIdentification13TCH3) MarshalXML 

func (v PersonIdentification13TCH3) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (PersonIdentification13TCH3) Validate 

func (v PersonIdentification13TCH3) Validate() error

type PersonIdentificationSchemeName1Choice 

type PersonIdentificationSchemeName1Choice struct {
	Prtry *Max35Text `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Prtry,omitempty"`
}

func (PersonIdentificationSchemeName1Choice) MarshalXML 

func (v PersonIdentificationSchemeName1Choice) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (PersonIdentificationSchemeName1Choice) Validate 

func (v PersonIdentificationSchemeName1Choice) Validate() error

type PhoneNumber 

type PhoneNumber string

func (PhoneNumber) Validate 

func (v PhoneNumber) Validate() error

type PostalAddress24 

type PostalAddress24 struct {
	StrtNm      Max70Text   `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 StrtNm"`
	BldgNb      *Max16Text  `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 BldgNb,omitempty"`
	PstCd       Max16Text   `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 PstCd"`
	TwnNm       Max35Text   `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 TwnNm"`
	CtrySubDvsn Max35Text   `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 CtrySubDvsn"`
	Ctry        CountryCode `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Ctry"`
	AdrLine     *Max70Text  `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 AdrLine,omitempty"`
}

func (PostalAddress24) MarshalXML 

func (v PostalAddress24) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (PostalAddress24) Validate 

func (v PostalAddress24) Validate() error

type PostalAddress24TCH 

type PostalAddress24TCH struct {
	StrtNm      Max70Text   `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 StrtNm"`
	BldgNb      *Max16Text  `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 BldgNb,omitempty"`
	PstCd       Max16Text   `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 PstCd"`
	TwnNm       Max35Text   `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 TwnNm"`
	CtrySubDvsn Max35Text   `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 CtrySubDvsn"`
	Ctry        CountryCode `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Ctry"`
	AdrLine     *Max70Text  `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 AdrLine,omitempty"`
}

func (PostalAddress24TCH) MarshalXML 

func (v PostalAddress24TCH) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (PostalAddress24TCH) Validate 

func (v PostalAddress24TCH) Validate() error

type RemittanceAmount2 

type RemittanceAmount2 struct {
	DscntApldAmt []*DiscountAmountAndType1 `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 DscntApldAmt,omitempty"`
}

func (RemittanceAmount2) MarshalXML 

func (v RemittanceAmount2) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (RemittanceAmount2) Validate 

func (v RemittanceAmount2) Validate() error

type RemittanceAmount2TCH 

type RemittanceAmount2TCH struct {
	DscntApldAmt []*DiscountAmountAndType1TCH `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 DscntApldAmt,omitempty"`
}

func (RemittanceAmount2TCH) MarshalXML 

func (v RemittanceAmount2TCH) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (RemittanceAmount2TCH) Validate 

func (v RemittanceAmount2TCH) Validate() error

type RemittanceInformation16 

type RemittanceInformation16 struct {
	Ustrd []*Max140Text                      `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Ustrd,omitempty"`
	Strd  *StructuredRemittanceInformation16 `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Strd,omitempty"`
}

func (RemittanceInformation16) MarshalXML 

func (v RemittanceInformation16) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (RemittanceInformation16) Validate 

func (v RemittanceInformation16) Validate() error

type RemittanceInformation16TCH 

type RemittanceInformation16TCH struct {
	Ustrd []*Max140Text                         `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Ustrd,omitempty"`
	Strd  *StructuredRemittanceInformation16TCH `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Strd,omitempty"`
}

func (RemittanceInformation16TCH) MarshalXML 

func (v RemittanceInformation16TCH) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (RemittanceInformation16TCH) Validate 

func (v RemittanceInformation16TCH) Validate() error

type StructuredRemittanceInformation16 

type StructuredRemittanceInformation16 struct {
	RfrdDocAmt *RemittanceAmount2 `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 RfrdDocAmt,omitempty"`
}

func (StructuredRemittanceInformation16) MarshalXML 

func (v StructuredRemittanceInformation16) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (StructuredRemittanceInformation16) Validate 

func (v StructuredRemittanceInformation16) Validate() error

type StructuredRemittanceInformation16TCH 

type StructuredRemittanceInformation16TCH struct {
	RfrdDocAmt *RemittanceAmount2TCH `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 RfrdDocAmt,omitempty"`
}

func (StructuredRemittanceInformation16TCH) MarshalXML 

func (v StructuredRemittanceInformation16TCH) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (StructuredRemittanceInformation16TCH) Validate 

func (v StructuredRemittanceInformation16TCH) Validate() error

type UUIDv4Identifier 

type UUIDv4Identifier string

func (UUIDv4Identifier) Validate 

func (v UUIDv4Identifier) Validate() error

type UnderlyingGroupInformation1 

type UnderlyingGroupInformation1 struct {
	OrgnlMsgId   Max35Text   `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 OrgnlMsgId"`
	OrgnlMsgNmId OrigMsgName `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 OrgnlMsgNmId"`
}

func (UnderlyingGroupInformation1) MarshalXML 

func (v UnderlyingGroupInformation1) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (UnderlyingGroupInformation1) Validate 

func (v UnderlyingGroupInformation1) Validate() error

type UnderlyingGroupInformation1TCH 

type UnderlyingGroupInformation1TCH struct {
	OrgnlMsgId   Max35Text      `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 OrgnlMsgId"`
	OrgnlMsgNmId OrigMsgNameTCH `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 OrgnlMsgNmId"`
}

func (UnderlyingGroupInformation1TCH) MarshalXML 

func (v UnderlyingGroupInformation1TCH) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (UnderlyingGroupInformation1TCH) Validate 

func (v UnderlyingGroupInformation1TCH) Validate() error

type UnderlyingGroupInformation1TCH2 

type UnderlyingGroupInformation1TCH2 struct {
	OrgnlMsgId   Max35Text       `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 OrgnlMsgId"`
	OrgnlMsgNmId OrigMsgNameTCH2 `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 OrgnlMsgNmId"`
}

func (UnderlyingGroupInformation1TCH2) MarshalXML 

func (v UnderlyingGroupInformation1TCH2) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (UnderlyingGroupInformation1TCH2) Validate 

func (v UnderlyingGroupInformation1TCH2) Validate() error

type UnderlyingPaymentInstruction5 

type UnderlyingPaymentInstruction5 struct {
	OrgnlGrpInf     UnderlyingGroupInformation1       `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 OrgnlGrpInf"`
	OrgnlPmtInfId   Max35Text                         `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 OrgnlPmtInfId"`
	OrgnlEndToEndId *Max35Text                        `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 OrgnlEndToEndId,omitempty"`
	OrgnlUETR       *UUIDv4Identifier                 `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 OrgnlUETR,omitempty"`
	OrgnlInstdAmt   ActiveOrHistoricCurrencyAndAmount `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 OrgnlInstdAmt"`
	ReqdExctnDt     *DateAndDateTime2Choice           `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 ReqdExctnDt,omitempty"`
}

func (UnderlyingPaymentInstruction5) MarshalXML 

func (v UnderlyingPaymentInstruction5) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (UnderlyingPaymentInstruction5) Validate 

func (v UnderlyingPaymentInstruction5) Validate() error

type UnderlyingPaymentInstruction5TCH 

type UnderlyingPaymentInstruction5TCH struct {
	OrgnlGrpInf     UnderlyingGroupInformation1TCH    `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 OrgnlGrpInf"`
	OrgnlPmtInfId   Max35Text                         `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 OrgnlPmtInfId"`
	OrgnlEndToEndId *Max35Text                        `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 OrgnlEndToEndId,omitempty"`
	OrgnlUETR       *UUIDv4Identifier                 `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 OrgnlUETR,omitempty"`
	OrgnlInstdAmt   ActiveOrHistoricCurrencyAndAmount `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 OrgnlInstdAmt"`
	ReqdExctnDt     *DateAndDateTime2Choice           `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 ReqdExctnDt,omitempty"`
}

func (UnderlyingPaymentInstruction5TCH) MarshalXML 

func (v UnderlyingPaymentInstruction5TCH) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (UnderlyingPaymentInstruction5TCH) Validate 

func (v UnderlyingPaymentInstruction5TCH) Validate() error

type UnderlyingPaymentTransaction4 

type UnderlyingPaymentTransaction4 struct {
	OrgnlGrpInf         UnderlyingGroupInformation1       `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 OrgnlGrpInf"`
	OrgnlInstrId        Max35Text                         `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 OrgnlInstrId"`
	OrgnlEndToEndId     *Max35Text                        `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 OrgnlEndToEndId,omitempty"`
	OrgnlTxId           Max35Text                         `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 OrgnlTxId"`
	OrgnlUETR           *UUIDv4Identifier                 `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 OrgnlUETR,omitempty"`
	OrgnlIntrBkSttlmAmt ActiveOrHistoricCurrencyAndAmount `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 OrgnlIntrBkSttlmAmt"`
	OrgnlIntrBkSttlmDt  rtp.ISODate                       `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 OrgnlIntrBkSttlmDt"`
}

func (UnderlyingPaymentTransaction4) MarshalXML 

func (v UnderlyingPaymentTransaction4) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (UnderlyingPaymentTransaction4) Validate 

func (v UnderlyingPaymentTransaction4) Validate() error

type UnderlyingPaymentTransaction4TCH 

type UnderlyingPaymentTransaction4TCH struct {
	OrgnlGrpInf         UnderlyingGroupInformation1TCH2   `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 OrgnlGrpInf"`
	OrgnlInstrId        Max35Text                         `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 OrgnlInstrId"`
	OrgnlEndToEndId     *Max35Text                        `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 OrgnlEndToEndId,omitempty"`
	OrgnlTxId           Max35Text                         `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 OrgnlTxId"`
	OrgnlUETR           *UUIDv4Identifier                 `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 OrgnlUETR,omitempty"`
	OrgnlIntrBkSttlmAmt ActiveOrHistoricCurrencyAndAmount `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 OrgnlIntrBkSttlmAmt"`
	OrgnlIntrBkSttlmDt  rtp.ISODate                       `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 OrgnlIntrBkSttlmDt"`
}

func (UnderlyingPaymentTransaction4TCH) MarshalXML 

func (v UnderlyingPaymentTransaction4TCH) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (UnderlyingPaymentTransaction4TCH) Validate 

func (v UnderlyingPaymentTransaction4TCH) Validate() error

type UnderlyingTransaction5Choice 

type UnderlyingTransaction5Choice struct {
	Initn  *UnderlyingPaymentInstruction5 `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Initn,omitempty"`
	IntrBk *UnderlyingPaymentTransaction4 `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 IntrBk,omitempty"`
}

func (UnderlyingTransaction5Choice) MarshalXML 

func (v UnderlyingTransaction5Choice) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (UnderlyingTransaction5Choice) Validate 

func (v UnderlyingTransaction5Choice) Validate() error

type UnderlyingTransaction5ChoiceTCH 

type UnderlyingTransaction5ChoiceTCH struct {
	Initn  *UnderlyingPaymentInstruction5TCH `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 Initn,omitempty"`
	IntrBk *UnderlyingPaymentTransaction4TCH `xml:"urn:iso:std:iso:20022:tech:xsd:camt.028.001.09 IntrBk,omitempty"`
}

func (UnderlyingTransaction5ChoiceTCH) MarshalXML 

func (v UnderlyingTransaction5ChoiceTCH) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML is a custom marshaller that allows us to manipulate the XML tag in order to use the proper namespace prefix

func (UnderlyingTransaction5ChoiceTCH) Validate 

func (v UnderlyingTransaction5ChoiceTCH) Validate() error

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.