pacs

type Document00200102 ¶

type Document00200102 struct {
	XMLName xml.Name                `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.002.001.02 Document"`
	Message *PaymentStatusReportV02 `xml:"pacs.002.001.02"`
}

func (d *Document00200102) AddMessage() *PaymentStatusReportV02

type Document00200103 ¶

type Document00200103 struct {
	XMLName xml.Name                      `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.002.001.03 Document"`
	Message *FIToFIPaymentStatusReportV03 `xml:"FIToFIPmtStsRpt"`
}

func (d *Document00200103) AddMessage() *FIToFIPaymentStatusReportV03

type Document00200104 ¶

type Document00200104 struct {
	XMLName xml.Name                      `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.002.001.04 Document"`
	Message *FIToFIPaymentStatusReportV04 `xml:"FIToFIPmtStsRpt"`
}

func (d *Document00200104) AddMessage() *FIToFIPaymentStatusReportV04

type Document00200105 ¶

type Document00200105 struct {
	XMLName xml.Name                      `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.002.001.05 Document"`
	Message *FIToFIPaymentStatusReportV05 `xml:"FIToFIPmtStsRpt"`
}

func (d *Document00200105) AddMessage() *FIToFIPaymentStatusReportV05

type Document00200106 ¶

type Document00200106 struct {
	XMLName xml.Name                      `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.002.001.06 Document"`
	Message *FIToFIPaymentStatusReportV06 `xml:"FIToFIPmtStsRpt"`
}

func (d *Document00200106) AddMessage() *FIToFIPaymentStatusReportV06

type Document00200107 ¶

type Document00200107 struct {
	XMLName xml.Name                      `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.002.001.07 Document"`
	Message *FIToFIPaymentStatusReportV07 `xml:"FIToFIPmtStsRpt"`
}

func (d *Document00200107) AddMessage() *FIToFIPaymentStatusReportV07

type Document00200108 ¶

type Document00200108 struct {
	XMLName xml.Name                      `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.002.001.08 Document"`
	Message *FIToFIPaymentStatusReportV08 `xml:"FIToFIPmtStsRpt"`
}

func (d *Document00200108) AddMessage() *FIToFIPaymentStatusReportV08

type Document00300101 ¶

type Document00300101 struct {
	XMLName xml.Name                      `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.003.001.01 Document"`
	Message *FIToFICustomerDirectDebitV01 `xml:"pacs.003.001.01"`
}

func (d *Document00300101) AddMessage() *FIToFICustomerDirectDebitV01

type Document00300102 ¶

type Document00300102 struct {
	XMLName xml.Name                      `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.003.001.02 Document"`
	Message *FIToFICustomerDirectDebitV02 `xml:"FIToFICstmrDrctDbt"`
}

func (d *Document00300102) AddMessage() *FIToFICustomerDirectDebitV02

type Document00300103 ¶

type Document00300103 struct {
	XMLName xml.Name                      `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.003.001.03 Document"`
	Message *FIToFICustomerDirectDebitV03 `xml:"FIToFICstmrDrctDbt"`
}

func (d *Document00300103) AddMessage() *FIToFICustomerDirectDebitV03

type Document00300104 ¶

type Document00300104 struct {
	XMLName xml.Name                      `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.003.001.04 Document"`
	Message *FIToFICustomerDirectDebitV04 `xml:"FIToFICstmrDrctDbt"`
}

func (d *Document00300104) AddMessage() *FIToFICustomerDirectDebitV04

type Document00300105 ¶

type Document00300105 struct {
	XMLName xml.Name                      `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.003.001.05 Document"`
	Message *FIToFICustomerDirectDebitV05 `xml:"FIToFICstmrDrctDbt"`
}

func (d *Document00300105) AddMessage() *FIToFICustomerDirectDebitV05

type Document00300106 ¶

type Document00300106 struct {
	XMLName xml.Name                      `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.003.001.06 Document"`
	Message *FIToFICustomerDirectDebitV06 `xml:"FIToFICstmrDrctDbt"`
}

func (d *Document00300106) AddMessage() *FIToFICustomerDirectDebitV06

type Document00300107 ¶

type Document00300107 struct {
	XMLName xml.Name                      `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.003.001.07 Document"`
	Message *FIToFICustomerDirectDebitV07 `xml:"FIToFICstmrDrctDbt"`
}

func (d *Document00300107) AddMessage() *FIToFICustomerDirectDebitV07

type Document00400101 ¶

type Document00400101 struct {
	XMLName xml.Name          `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.004.001.01 Document"`
	Message *PaymentReturnV01 `xml:"pacs.004.001.01"`
}

func (d *Document00400101) AddMessage() *PaymentReturnV01

type Document00400102 ¶

type Document00400102 struct {
	XMLName xml.Name          `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.004.001.02 Document"`
	Message *PaymentReturnV02 `xml:"PmtRtr"`
}

func (d *Document00400102) AddMessage() *PaymentReturnV02

type Document00400103 ¶

type Document00400103 struct {
	XMLName xml.Name          `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.004.001.03 Document"`
	Message *PaymentReturnV03 `xml:"PmtRtr"`
}

func (d *Document00400103) AddMessage() *PaymentReturnV03

type Document00400104 ¶

type Document00400104 struct {
	XMLName xml.Name          `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.004.001.04 Document"`
	Message *PaymentReturnV04 `xml:"PmtRtr"`
}

func (d *Document00400104) AddMessage() *PaymentReturnV04

type Document00400105 ¶

type Document00400105 struct {
	XMLName xml.Name          `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.004.001.05 Document"`
	Message *PaymentReturnV05 `xml:"PmtRtr"`
}

func (d *Document00400105) AddMessage() *PaymentReturnV05

type Document00400106 ¶

type Document00400106 struct {
	XMLName xml.Name          `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.004.001.06 Document"`
	Message *PaymentReturnV06 `xml:"PmtRtr"`
}

func (d *Document00400106) AddMessage() *PaymentReturnV06

type Document00400107 ¶

type Document00400107 struct {
	XMLName xml.Name          `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.004.001.07 Document"`
	Message *PaymentReturnV07 `xml:"PmtRtr"`
}

func (d *Document00400107) AddMessage() *PaymentReturnV07

type Document00600101 ¶

type Document00600101 struct {
	XMLName xml.Name                       `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.006.001.01 Document"`
	Message *PaymentCancellationRequestV01 `xml:"pacs.006.001.01"`
}

func (d *Document00600101) AddMessage() *PaymentCancellationRequestV01

type Document00700101 ¶

type Document00700101 struct {
	XMLName xml.Name                  `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.007.001.01 Document"`
	Message *FIToFIPaymentReversalV01 `xml:"pacs.007.001.01"`
}

func (d *Document00700101) AddMessage() *FIToFIPaymentReversalV01

type Document00700102 ¶

type Document00700102 struct {
	XMLName xml.Name                  `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.007.001.02 Document"`
	Message *FIToFIPaymentReversalV02 `xml:"FIToFIPmtRvsl"`
}

func (d *Document00700102) AddMessage() *FIToFIPaymentReversalV02

type Document00700103 ¶

type Document00700103 struct {
	XMLName xml.Name                  `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.007.001.03 Document"`
	Message *FIToFIPaymentReversalV03 `xml:"FIToFIPmtRvsl"`
}

func (d *Document00700103) AddMessage() *FIToFIPaymentReversalV03

type Document00700104 ¶

type Document00700104 struct {
	XMLName xml.Name                  `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.007.001.04 Document"`
	Message *FIToFIPaymentReversalV04 `xml:"FIToFIPmtRvsl"`
}

func (d *Document00700104) AddMessage() *FIToFIPaymentReversalV04

type Document00700105 ¶

type Document00700105 struct {
	XMLName xml.Name                  `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.007.001.05 Document"`
	Message *FIToFIPaymentReversalV05 `xml:"FIToFIPmtRvsl"`
}

func (d *Document00700105) AddMessage() *FIToFIPaymentReversalV05

type Document00700106 ¶

type Document00700106 struct {
	XMLName xml.Name                  `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.007.001.06 Document"`
	Message *FIToFIPaymentReversalV06 `xml:"FIToFIPmtRvsl"`
}

func (d *Document00700106) AddMessage() *FIToFIPaymentReversalV06

type Document00700107 ¶

type Document00700107 struct {
	XMLName xml.Name                  `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.007.001.07 Document"`
	Message *FIToFIPaymentReversalV07 `xml:"FIToFIPmtRvsl"`
}

func (d *Document00700107) AddMessage() *FIToFIPaymentReversalV07

type Document00800101 ¶

type Document00800101 struct {
	XMLName xml.Name                         `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.008.001.01 Document"`
	Message *FIToFICustomerCreditTransferV01 `xml:"pacs.008.001.01"`
}

func (d *Document00800101) AddMessage() *FIToFICustomerCreditTransferV01

type Document00800102 ¶

type Document00800102 struct {
	XMLName xml.Name                         `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.008.001.02 Document"`
	Message *FIToFICustomerCreditTransferV02 `xml:"FIToFICstmrCdtTrf"`
}

func (d *Document00800102) AddMessage() *FIToFICustomerCreditTransferV02

type Document00800103 ¶

type Document00800103 struct {
	XMLName xml.Name                         `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.008.001.03 Document"`
	Message *FIToFICustomerCreditTransferV03 `xml:"FIToFICstmrCdtTrf"`
}

func (d *Document00800103) AddMessage() *FIToFICustomerCreditTransferV03

type Document00800104 ¶

type Document00800104 struct {
	XMLName xml.Name                         `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.008.001.04 Document"`
	Message *FIToFICustomerCreditTransferV04 `xml:"FIToFICstmrCdtTrf"`
}

func (d *Document00800104) AddMessage() *FIToFICustomerCreditTransferV04

type Document00800105 ¶

type Document00800105 struct {
	XMLName xml.Name                         `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.008.001.05 Document"`
	Message *FIToFICustomerCreditTransferV05 `xml:"FIToFICstmrCdtTrf"`
}

func (d *Document00800105) AddMessage() *FIToFICustomerCreditTransferV05

type Document00800106 ¶

type Document00800106 struct {
	XMLName xml.Name                         `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.008.001.06 Document"`
	Message *FIToFICustomerCreditTransferV06 `xml:"FIToFICstmrCdtTrf"`
}

func (d *Document00800106) AddMessage() *FIToFICustomerCreditTransferV06

type Document00900101 ¶

type Document00900101 struct {
	XMLName xml.Name                               `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.009.001.01 Document"`
	Message *FinancialInstitutionCreditTransferV01 `xml:"pacs.009.001.01"`
}

func (d *Document00900101) AddMessage() *FinancialInstitutionCreditTransferV01

type Document00900102 ¶

type Document00900102 struct {
	XMLName xml.Name                               `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.009.001.02 Document"`
	Message *FinancialInstitutionCreditTransferV02 `xml:"FinInstnCdtTrf"`
}

func (d *Document00900102) AddMessage() *FinancialInstitutionCreditTransferV02

type Document00900103 ¶

type Document00900103 struct {
	XMLName xml.Name                               `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.009.001.03 Document"`
	Message *FinancialInstitutionCreditTransferV03 `xml:"FinInstnCdtTrf"`
}

func (d *Document00900103) AddMessage() *FinancialInstitutionCreditTransferV03

type Document00900104 ¶

type Document00900104 struct {
	XMLName xml.Name                               `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.009.001.04 Document"`
	Message *FinancialInstitutionCreditTransferV04 `xml:"FICdtTrf"`
}

func (d *Document00900104) AddMessage() *FinancialInstitutionCreditTransferV04

type Document00900105 ¶

type Document00900105 struct {
	XMLName xml.Name                               `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.009.001.05 Document"`
	Message *FinancialInstitutionCreditTransferV05 `xml:"FICdtTrf"`
}

func (d *Document00900105) AddMessage() *FinancialInstitutionCreditTransferV05

type Document00900106 ¶

type Document00900106 struct {
	XMLName xml.Name                               `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.009.001.06 Document"`
	Message *FinancialInstitutionCreditTransferV06 `xml:"FICdtTrf"`
}

func (d *Document00900106) AddMessage() *FinancialInstitutionCreditTransferV06

type Document01000102 ¶

type Document01000102 struct {
	XMLName xml.Name                            `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.010.001.02 Document"`
	Message *FinancialInstitutionDirectDebitV02 `xml:"FIDrctDbt"`
}

func (d *Document01000102) AddMessage() *FinancialInstitutionDirectDebitV02

type Document02800101 ¶

type Document02800101 struct {
	XMLName xml.Name                       `xml:"urn:iso:std:iso:20022:tech:xsd:pacs.028.001.01 Document"`
	Message *FIToFIPaymentStatusRequestV01 `xml:"FIToFIPmtStsReq"`
}

func (d *Document02800101) AddMessage() *FIToFIPaymentStatusRequestV01

type FIToFICustomerCreditTransferV01 ¶

type FIToFICustomerCreditTransferV01 struct {

	// Set of characteristics shared by all individual transactions included in the message.
	GroupHeader *iso20022.GroupHeader2 `xml:"GrpHdr"`

	// Set of elements providing information specific to the individual credit transfer(s).
	CreditTransferTransactionInformation []*iso20022.CreditTransferTransactionInformation2 `xml:"CdtTrfTxInf"`
}

Scope The FinancialInstitutionToFinancialInstitutionCustomerCreditTransfer message is sent by the debtor agent to the creditor agent, directly or through other agents and/or a payment clearing and settlement system. It is used to move funds from a debtor account to a creditor. Usage The FIToFICustomerCreditTransfer message is exchanged between agents and can contain one or more customer credit transfer instructions. The FIToFICustomerCreditTransfer message does not allow for grouping: a CreditTransferTransactionInformation block must be present for each credit transfer transaction. The FIToFICustomerCreditTransfer message can be used in different ways: - If the instructing agent and the instructed agent wish to use their direct account relationship in the currency of the transfer then the message contains both the funds for the customer transfer(s) as well as the payment details; - If the instructing agent and the instructed agent have no direct account relationship in the currency of the transfer, or do not wish to use their account relationship, then other (reimbursement) agents will be involved to cover for the customer transfer(s). The FIToFICustomerCreditTransfer contains only the payment details and the instructing agent must cover the customer transfer by sending a FinancialInstitutionCreditTransfer to a reimbursement agent. This payment method is called the Cover method; - If more than two financial institutions are involved in the payment chain and if the FIToFICustomerCreditTransfer is sent from one financial institution to the next financial institution in the payment chain, then the payment method is called the Serial method. The FIToFICustomerCreditTransfer message can be used in domestic and cross-border scenarios.

func (f *FIToFICustomerCreditTransferV01) AddCreditTransferTransactionInformation() *iso20022.CreditTransferTransactionInformation2

func (f *FIToFICustomerCreditTransferV01) AddGroupHeader() *iso20022.GroupHeader2

type FIToFICustomerCreditTransferV02 ¶

type FIToFICustomerCreditTransferV02 struct {

	// Set of characteristics shared by all individual transactions included in the message.
	GroupHeader *iso20022.GroupHeader33 `xml:"GrpHdr"`

	// Set of elements providing information specific to the individual credit transfer(s).
	CreditTransferTransactionInformation []*iso20022.CreditTransferTransactionInformation11 `xml:"CdtTrfTxInf"`
}

Scope The FinancialInstitutionToFinancialInstitutionCustomerCreditTransfer message is sent by the debtor agent to the creditor agent, directly or through other agents and/or a payment clearing and settlement system. It is used to move funds from a debtor account to a creditor. Usage The FIToFICustomerCreditTransfer message is exchanged between agents and can contain one or more customer credit transfer instructions. The FIToFICustomerCreditTransfer message does not allow for grouping: a CreditTransferTransactionInformation block must be present for each credit transfer transaction. The FIToFICustomerCreditTransfer message can be used in different ways: - If the instructing agent and the instructed agent wish to use their direct account relationship in the currency of the transfer then the message contains both the funds for the customer transfer(s) as well as the payment details; - If the instructing agent and the instructed agent have no direct account relationship in the currency of the transfer, or do not wish to use their account relationship, then other (reimbursement) agents will be involved to cover for the customer transfer(s). The FIToFICustomerCreditTransfer contains only the payment details and the instructing agent must cover the customer transfer by sending a FinancialInstitutionCreditTransfer to a reimbursement agent. This payment method is called the Cover method; - If more than two financial institutions are involved in the payment chain and if the FIToFICustomerCreditTransfer is sent from one financial institution to the next financial institution in the payment chain, then the payment method is called the Serial method. The FIToFICustomerCreditTransfer message can be used in domestic and cross-border scenarios.

func (f *FIToFICustomerCreditTransferV02) AddCreditTransferTransactionInformation() *iso20022.CreditTransferTransactionInformation11

func (f *FIToFICustomerCreditTransferV02) AddGroupHeader() *iso20022.GroupHeader33

type FIToFICustomerCreditTransferV03 ¶

type FIToFICustomerCreditTransferV03 struct {

	// Set of characteristics shared by all individual transactions included in the message.
	GroupHeader *iso20022.GroupHeader49 `xml:"GrpHdr"`

	// Set of elements providing information specific to the individual credit transfer(s).
	CreditTransferTransactionInformation []*iso20022.CreditTransferTransaction2 `xml:"CdtTrfTxInf"`

	// Additional information that cannot be captured in the structured elements and/or any other specific block.
	SupplementaryData []*iso20022.SupplementaryData1 `xml:"SplmtryData,omitempty"`
}

Scope The FinancialInstitutionToFinancialInstitutionCustomerCreditTransfer message is sent by the debtor agent to the creditor agent, directly or through other agents and/or a payment clearing and settlement system. It is used to move funds from a debtor account to a creditor. Usage The FIToFICustomerCreditTransfer message is exchanged between agents and can contain one or more customer credit transfer instructions. The FIToFICustomerCreditTransfer message does not allow for grouping: a CreditTransferTransactionInformation block must be present for each credit transfer transaction. The FIToFICustomerCreditTransfer message can be used in different ways: - If the instructing agent and the instructed agent wish to use their direct account relationship in the currency of the transfer then the message contains both the funds for the customer transfer(s) as well as the payment details; - If the instructing agent and the instructed agent have no direct account relationship in the currency of the transfer, or do not wish to use their account relationship, then other (reimbursement) agents will be involved to cover for the customer transfer(s). The FIToFICustomerCreditTransfer contains only the payment details and the instructing agent must cover the customer transfer by sending a FinancialInstitutionCreditTransfer to a reimbursement agent. This payment method is called the Cover method; - If more than two financial institutions are involved in the payment chain and if the FIToFICustomerCreditTransfer is sent from one financial institution to the next financial institution in the payment chain, then the payment method is called the Serial method. The FIToFICustomerCreditTransfer message can be used in domestic and cross-border scenarios.

func (f *FIToFICustomerCreditTransferV03) AddCreditTransferTransactionInformation() *iso20022.CreditTransferTransaction2

func (f *FIToFICustomerCreditTransferV03) AddGroupHeader() *iso20022.GroupHeader49

func (f *FIToFICustomerCreditTransferV03) AddSupplementaryData() *iso20022.SupplementaryData1

type FIToFICustomerCreditTransferV04 ¶

type FIToFICustomerCreditTransferV04 struct {

	// Set of characteristics shared by all individual transactions included in the message.
	GroupHeader *iso20022.GroupHeader49 `xml:"GrpHdr"`

	// Set of elements providing information specific to the individual credit transfer(s).
	CreditTransferTransactionInformation []*iso20022.CreditTransferTransaction7 `xml:"CdtTrfTxInf"`

	// Additional information that cannot be captured in the structured elements and/or any other specific block.
	SupplementaryData []*iso20022.SupplementaryData1 `xml:"SplmtryData,omitempty"`
}

Scope The FinancialInstitutionToFinancialInstitutionCustomerCreditTransfer message is sent by the debtor agent to the creditor agent, directly or through other agents and/or a payment clearing and settlement system. It is used to move funds from a debtor account to a creditor. Usage The FIToFICustomerCreditTransfer message is exchanged between agents and can contain one or more customer credit transfer instructions. The FIToFICustomerCreditTransfer message does not allow for grouping: a CreditTransferTransactionInformation block must be present for each credit transfer transaction. The FIToFICustomerCreditTransfer message can be used in different ways: - If the instructing agent and the instructed agent wish to use their direct account relationship in the currency of the transfer then the message contains both the funds for the customer transfer(s) as well as the payment details; - If the instructing agent and the instructed agent have no direct account relationship in the currency of the transfer, or do not wish to use their account relationship, then other (reimbursement) agents will be involved to cover for the customer transfer(s). The FIToFICustomerCreditTransfer contains only the payment details and the instructing agent must cover the customer transfer by sending a FinancialInstitutionCreditTransfer to a reimbursement agent. This payment method is called the Cover method; - If more than two financial institutions are involved in the payment chain and if the FIToFICustomerCreditTransfer is sent from one financial institution to the next financial institution in the payment chain, then the payment method is called the Serial method. The FIToFICustomerCreditTransfer message can be used in domestic and cross-border scenarios.

func (f *FIToFICustomerCreditTransferV04) AddCreditTransferTransactionInformation() *iso20022.CreditTransferTransaction7

func (f *FIToFICustomerCreditTransferV04) AddGroupHeader() *iso20022.GroupHeader49

func (f *FIToFICustomerCreditTransferV04) AddSupplementaryData() *iso20022.SupplementaryData1

type FIToFICustomerCreditTransferV05 ¶

type FIToFICustomerCreditTransferV05 struct {

	// Set of characteristics shared by all individual transactions included in the message.
	GroupHeader *iso20022.GroupHeader49 `xml:"GrpHdr"`

	// Set of elements providing information specific to the individual credit transfer(s).
	CreditTransferTransactionInformation []*iso20022.CreditTransferTransaction19 `xml:"CdtTrfTxInf"`

	// Additional information that cannot be captured in the structured elements and/or any other specific block.
	SupplementaryData []*iso20022.SupplementaryData1 `xml:"SplmtryData,omitempty"`
}

Scope The FinancialInstitutionToFinancialInstitutionCustomerCreditTransfer message is sent by the debtor agent to the creditor agent, directly or through other agents and/or a payment clearing and settlement system. It is used to move funds from a debtor account to a creditor. Usage The FIToFICustomerCreditTransfer message is exchanged between agents and can contain one or more customer credit transfer instructions. The FIToFICustomerCreditTransfer message does not allow for grouping: a CreditTransferTransactionInformation block must be present for each credit transfer transaction. The FIToFICustomerCreditTransfer message can be used in different ways: - If the instructing agent and the instructed agent wish to use their direct account relationship in the currency of the transfer then the message contains both the funds for the customer transfer(s) as well as the payment details; - If the instructing agent and the instructed agent have no direct account relationship in the currency of the transfer, or do not wish to use their account relationship, then other (reimbursement) agents will be involved to cover for the customer transfer(s). The FIToFICustomerCreditTransfer contains only the payment details and the instructing agent must cover the customer transfer by sending a FinancialInstitutionCreditTransfer to a reimbursement agent. This payment method is called the Cover method; - If more than two financial institutions are involved in the payment chain and if the FIToFICustomerCreditTransfer is sent from one financial institution to the next financial institution in the payment chain, then the payment method is called the Serial method. The FIToFICustomerCreditTransfer message can be used in domestic and cross-border scenarios.

func (f *FIToFICustomerCreditTransferV05) AddCreditTransferTransactionInformation() *iso20022.CreditTransferTransaction19

func (f *FIToFICustomerCreditTransferV05) AddGroupHeader() *iso20022.GroupHeader49

func (f *FIToFICustomerCreditTransferV05) AddSupplementaryData() *iso20022.SupplementaryData1

type FIToFICustomerCreditTransferV06 ¶

type FIToFICustomerCreditTransferV06 struct {

	// Set of characteristics shared by all individual transactions included in the message.
	GroupHeader *iso20022.GroupHeader70 `xml:"GrpHdr"`

	// Set of elements providing information specific to the individual credit transfer(s).
	CreditTransferTransactionInformation []*iso20022.CreditTransferTransaction25 `xml:"CdtTrfTxInf"`

	// Additional information that cannot be captured in the structured elements and/or any other specific block.
	SupplementaryData []*iso20022.SupplementaryData1 `xml:"SplmtryData,omitempty"`
}

Scope The FinancialInstitutionToFinancialInstitutionCustomerCreditTransfer message is sent by the debtor agent to the creditor agent, directly or through other agents and/or a payment clearing and settlement system. It is used to move funds from a debtor account to a creditor. Usage The FIToFICustomerCreditTransfer message is exchanged between agents and can contain one or more customer credit transfer instructions. The FIToFICustomerCreditTransfer message does not allow for grouping: a CreditTransferTransactionInformation block must be present for each credit transfer transaction. The FIToFICustomerCreditTransfer message can be used in different ways: - If the instructing agent and the instructed agent wish to use their direct account relationship in the currency of the transfer then the message contains both the funds for the customer transfer(s) as well as the payment details; - If the instructing agent and the instructed agent have no direct account relationship in the currency of the transfer, or do not wish to use their account relationship, then other (reimbursement) agents will be involved to cover for the customer transfer(s). The FIToFICustomerCreditTransfer contains only the payment details and the instructing agent must cover the customer transfer by sending a FinancialInstitutionCreditTransfer to a reimbursement agent. This payment method is called the Cover method; - If more than two financial institutions are involved in the payment chain and if the FIToFICustomerCreditTransfer is sent from one financial institution to the next financial institution in the payment chain, then the payment method is called the Serial method. The FIToFICustomerCreditTransfer message can be used in domestic and cross-border scenarios.

func (f *FIToFICustomerCreditTransferV06) AddCreditTransferTransactionInformation() *iso20022.CreditTransferTransaction25

func (f *FIToFICustomerCreditTransferV06) AddGroupHeader() *iso20022.GroupHeader70

func (f *FIToFICustomerCreditTransferV06) AddSupplementaryData() *iso20022.SupplementaryData1

type FIToFICustomerDirectDebitV01 ¶

type FIToFICustomerDirectDebitV01 struct {

	// Set of characteristics shared by all individual transactions included in the message.
	GroupHeader *iso20022.GroupHeader3 `xml:"GrpHdr"`

	// Set of elements providing information specific to the individual direct debit(s).
	DirectDebitTransactionInformation []*iso20022.DirectDebitTransactionInformation2 `xml:"DrctDbtTxInf"`
}

Scope The FinancialInstitutionToFinancialInstitutionCustomerDirectDebit message is sent by the creditor agent to the debtor agent, directly or through other agents and/or a payment clearing and settlement system. It is used to collect funds from a debtor account for a creditor. Usage The FItoFICustomerDirectDebit message can contain one or more customer direct debit instructions. The FIToFICustomerDirectDebit message does not allow for grouping: the PaymentInformation block must be present once per occurrence of a DirectDebitTransactionInformation block. The FItoFICustomerDirectDebit message may or may not contain mandate related information, i.e. extracts from a mandate, such as the MandateIdentification or DateOfSignature. The FIToFICustomerDirectDebit message must not be considered as a mandate. The FItoFICustomerDirectDebit message can be used in domestic and cross-border scenarios.

func (f *FIToFICustomerDirectDebitV01) AddDirectDebitTransactionInformation() *iso20022.DirectDebitTransactionInformation2

func (f *FIToFICustomerDirectDebitV01) AddGroupHeader() *iso20022.GroupHeader3

type FIToFICustomerDirectDebitV02 ¶

type FIToFICustomerDirectDebitV02 struct {

	// Set of characteristics shared by all individual transactions included in the message.
	GroupHeader *iso20022.GroupHeader34 `xml:"GrpHdr"`

	// Set of elements providing information specific to the individual direct debit(s).
	DirectDebitTransactionInformation []*iso20022.DirectDebitTransactionInformation10 `xml:"DrctDbtTxInf"`
}

Scope The FinancialInstitutionToFinancialInstitutionCustomerDirectDebit message is sent by the creditor agent to the debtor agent, directly or through other agents and/or a payment clearing and settlement system. It is used to collect funds from a debtor account for a creditor. Usage The FItoFICustomerDirectDebit message can contain one or more customer direct debit instructions. The FIToFICustomerDirectDebit message does not allow for grouping: the PaymentInformation block must be present once per occurrence of a DirectDebitTransactionInformation block. The FItoFICustomerDirectDebit message may or may not contain mandate related information, i.e. extracts from a mandate, such as the MandateIdentification or DateOfSignature. The FIToFICustomerDirectDebit message must not be considered as a mandate. The FItoFICustomerDirectDebit message can be used in domestic and cross-border scenarios.

func (f *FIToFICustomerDirectDebitV02) AddDirectDebitTransactionInformation() *iso20022.DirectDebitTransactionInformation10

func (f *FIToFICustomerDirectDebitV02) AddGroupHeader() *iso20022.GroupHeader34

type FIToFICustomerDirectDebitV03 ¶

type FIToFICustomerDirectDebitV03 struct {

	// Set of characteristics shared by all individual transactions included in the message.
	GroupHeader *iso20022.GroupHeader50 `xml:"GrpHdr"`

	// Set of elements providing information specific to the individual direct debit(s).
	DirectDebitTransactionInformation []*iso20022.DirectDebitTransactionInformation12 `xml:"DrctDbtTxInf"`

	// Additional information that cannot be captured in the structured elements and/or any other specific block.
	SupplementaryData []*iso20022.SupplementaryData1 `xml:"SplmtryData,omitempty"`
}

Scope The FinancialInstitutionToFinancialInstitutionCustomerDirectDebit message is sent by the creditor agent to the debtor agent, directly or through other agents and/or a payment clearing and settlement system. It is used to collect funds from a debtor account for a creditor. Usage The FItoFICustomerDirectDebit message can contain one or more customer direct debit instructions. The FIToFICustomerDirectDebit message does not allow for grouping: the PaymentInformation block must be present once per occurrence of a DirectDebitTransactionInformation block. The FItoFICustomerDirectDebit message may or may not contain mandate related information, i.e. extracts from a mandate, such as the MandateIdentification or DateOfSignature. The FIToFICustomerDirectDebit message must not be considered as a mandate. The FItoFICustomerDirectDebit message can be used in domestic and cross-border scenarios.

func (f *FIToFICustomerDirectDebitV03) AddDirectDebitTransactionInformation() *iso20022.DirectDebitTransactionInformation12

func (f *FIToFICustomerDirectDebitV03) AddGroupHeader() *iso20022.GroupHeader50

func (f *FIToFICustomerDirectDebitV03) AddSupplementaryData() *iso20022.SupplementaryData1

type FIToFICustomerDirectDebitV04 ¶

type FIToFICustomerDirectDebitV04 struct {

	// Set of characteristics shared by all individual transactions included in the message.
	GroupHeader *iso20022.GroupHeader50 `xml:"GrpHdr"`

	// Set of elements providing information specific to the individual direct debit(s).
	DirectDebitTransactionInformation []*iso20022.DirectDebitTransactionInformation14 `xml:"DrctDbtTxInf"`

	// Additional information that cannot be captured in the structured elements and/or any other specific block.
	SupplementaryData []*iso20022.SupplementaryData1 `xml:"SplmtryData,omitempty"`
}

Scope The FinancialInstitutionToFinancialInstitutionCustomerDirectDebit message is sent by the creditor agent to the debtor agent, directly or through other agents and/or a payment clearing and settlement system. It is used to collect funds from a debtor account for a creditor. Usage The FItoFICustomerDirectDebit message can contain one or more customer direct debit instructions. The FIToFICustomerDirectDebit message does not allow for grouping: the PaymentInformation block must be present once per occurrence of a DirectDebitTransactionInformation block. The FItoFICustomerDirectDebit message may or may not contain mandate related information, i.e. extracts from a mandate, such as the MandateIdentification or DateOfSignature. The FIToFICustomerDirectDebit message must not be considered as a mandate. The FItoFICustomerDirectDebit message can be used in domestic and cross-border scenarios.

func (f *FIToFICustomerDirectDebitV04) AddDirectDebitTransactionInformation() *iso20022.DirectDebitTransactionInformation14

func (f *FIToFICustomerDirectDebitV04) AddGroupHeader() *iso20022.GroupHeader50

func (f *FIToFICustomerDirectDebitV04) AddSupplementaryData() *iso20022.SupplementaryData1

type FIToFICustomerDirectDebitV05 ¶

type FIToFICustomerDirectDebitV05 struct {

	// Set of characteristics shared by all individual transactions included in the message.
	GroupHeader *iso20022.GroupHeader50 `xml:"GrpHdr"`

	// Set of elements providing information specific to the individual direct debit(s).
	DirectDebitTransactionInformation []*iso20022.DirectDebitTransactionInformation17 `xml:"DrctDbtTxInf"`

	// Additional information that cannot be captured in the structured elements and/or any other specific block.
	SupplementaryData []*iso20022.SupplementaryData1 `xml:"SplmtryData,omitempty"`
}

Scope The FinancialInstitutionToFinancialInstitutionCustomerDirectDebit message is sent by the creditor agent to the debtor agent, directly or through other agents and/or a payment clearing and settlement system. It is used to collect funds from a debtor account for a creditor. Usage The FItoFICustomerDirectDebit message can contain one or more customer direct debit instructions. The FIToFICustomerDirectDebit message does not allow for grouping: the PaymentInformation block must be present once per occurrence of a DirectDebitTransactionInformation block. The FItoFICustomerDirectDebit message may or may not contain mandate related information, i.e. extracts from a mandate, such as the MandateIdentification or DateOfSignature. The FIToFICustomerDirectDebit message must not be considered as a mandate. The FItoFICustomerDirectDebit message can be used in domestic and cross-border scenarios.

func (f *FIToFICustomerDirectDebitV05) AddDirectDebitTransactionInformation() *iso20022.DirectDebitTransactionInformation17

func (f *FIToFICustomerDirectDebitV05) AddGroupHeader() *iso20022.GroupHeader50

func (f *FIToFICustomerDirectDebitV05) AddSupplementaryData() *iso20022.SupplementaryData1

type FIToFICustomerDirectDebitV06 ¶

type FIToFICustomerDirectDebitV06 struct {

	// Set of characteristics shared by all individual transactions included in the message.
	GroupHeader *iso20022.GroupHeader50 `xml:"GrpHdr"`

	// Set of elements providing information specific to the individual direct debit(s).
	DirectDebitTransactionInformation []*iso20022.DirectDebitTransactionInformation20 `xml:"DrctDbtTxInf"`

	// Additional information that cannot be captured in the structured elements and/or any other specific block.
	SupplementaryData []*iso20022.SupplementaryData1 `xml:"SplmtryData,omitempty"`
}

Scope The FinancialInstitutionToFinancialInstitutionCustomerDirectDebit message is sent by the creditor agent to the debtor agent, directly or through other agents and/or a payment clearing and settlement system. It is used to collect funds from a debtor account for a creditor. Usage The FItoFICustomerDirectDebit message can contain one or more customer direct debit instructions. The FIToFICustomerDirectDebit message does not allow for grouping. The FItoFICustomerDirectDebit message may or may not contain mandate related information, i.e. extracts from a mandate, such as the MandateIdentification or DateOfSignature. The FIToFICustomerDirectDebit message must not be considered as a mandate. The FItoFICustomerDirectDebit message can be used in domestic and cross-border scenarios.

func (f *FIToFICustomerDirectDebitV06) AddDirectDebitTransactionInformation() *iso20022.DirectDebitTransactionInformation20

func (f *FIToFICustomerDirectDebitV06) AddGroupHeader() *iso20022.GroupHeader50

func (f *FIToFICustomerDirectDebitV06) AddSupplementaryData() *iso20022.SupplementaryData1

type FIToFICustomerDirectDebitV07 ¶

type FIToFICustomerDirectDebitV07 struct {

	// Set of characteristics shared by all individual transactions included in the message.
	GroupHeader *iso20022.GroupHeader50 `xml:"GrpHdr"`

	// Set of elements providing information specific to the individual direct debit(s).
	DirectDebitTransactionInformation []*iso20022.DirectDebitTransactionInformation21 `xml:"DrctDbtTxInf"`

	// Additional information that cannot be captured in the structured elements and/or any other specific block.
	SupplementaryData []*iso20022.SupplementaryData1 `xml:"SplmtryData,omitempty"`
}

Scope The FinancialInstitutionToFinancialInstitutionCustomerDirectDebit message is sent by the creditor agent to the debtor agent, directly or through other agents and/or a payment clearing and settlement system. It is used to collect funds from a debtor account for a creditor. Usage The FItoFICustomerDirectDebit message can contain one or more customer direct debit instructions. The FIToFICustomerDirectDebit message does not allow for grouping. The FItoFICustomerDirectDebit message may or may not contain mandate related information, i.e. extracts from a mandate, such as the MandateIdentification or DateOfSignature. The FIToFICustomerDirectDebit message must not be considered as a mandate. The FItoFICustomerDirectDebit message can be used in domestic and cross-border scenarios.

func (f *FIToFICustomerDirectDebitV07) AddDirectDebitTransactionInformation() *iso20022.DirectDebitTransactionInformation21

func (f *FIToFICustomerDirectDebitV07) AddGroupHeader() *iso20022.GroupHeader50

func (f *FIToFICustomerDirectDebitV07) AddSupplementaryData() *iso20022.SupplementaryData1

type FIToFIPaymentReversalV01 ¶

type FIToFIPaymentReversalV01 struct {

	// Set of characteristics shared by all individual transactions included in the message.
	GroupHeader *iso20022.GroupHeader9 `xml:"GrpHdr"`

	// Information concerning the original group of transactions, to which the message refers.
	OriginalGroupInformation *iso20022.OriginalGroupInformation5 `xml:"OrgnlGrpInf"`

	// Information concerning the original transactions, to which the reversal message refers.
	TransactionInformation []*iso20022.PaymentTransactionInformation5 `xml:"TxInf,omitempty"`
}

Scope The FinancialInstitutionToFinancialInstitutionPaymentReversal message is sent by an agent to the next party in the payment chain. It is used to reverse a payment previously executed. Usage The FIToFIPaymentReversal message is exchanged between agents to reverse a FIToFICustomerDirectDebit message that has been settled. The result will be a credit on the debtor account. The FIToFIPaymentReversal message may or may not be the follow-up of a CustomerDirectDebitInitiation message. The FIToFIPaymentReversal message refers to the original FIToFICustomerDirectDebit message by means of references only or by means of references and a set of elements from the original instruction. The FIToFIPaymentReversal message can be used in domestic and cross-border scenarios.

func (f *FIToFIPaymentReversalV01) AddGroupHeader() *iso20022.GroupHeader9

func (f *FIToFIPaymentReversalV01) AddOriginalGroupInformation() *iso20022.OriginalGroupInformation5

func (f *FIToFIPaymentReversalV01) AddTransactionInformation() *iso20022.PaymentTransactionInformation5

type FIToFIPaymentReversalV02 ¶

type FIToFIPaymentReversalV02 struct {

	// Set of characteristics shared by all individual transactions included in the message.
	GroupHeader *iso20022.GroupHeader41 `xml:"GrpHdr"`

	// Information concerning the original group of transactions, to which the message refers.
	OriginalGroupInformation *iso20022.OriginalGroupInformation22 `xml:"OrgnlGrpInf"`

	// Information concerning the original transactions, to which the reversal message refers.
	TransactionInformation []*iso20022.PaymentTransactionInformation29 `xml:"TxInf,omitempty"`
}

Scope The FinancialInstitutionToFinancialInstitutionPaymentReversal message is sent by an agent to the next party in the payment chain. It is used to reverse a payment previously executed. Usage The FIToFIPaymentReversal message is exchanged between agents to reverse a FIToFICustomerDirectDebit message that has been settled. The result will be a credit on the debtor account. The FIToFIPaymentReversal message may or may not be the follow-up of a CustomerDirectDebitInitiation message. The FIToFIPaymentReversal message refers to the original FIToFICustomerDirectDebit message by means of references only or by means of references and a set of elements from the original instruction. The FIToFIPaymentReversal message can be used in domestic and cross-border scenarios.

func (f *FIToFIPaymentReversalV02) AddGroupHeader() *iso20022.GroupHeader41

func (f *FIToFIPaymentReversalV02) AddOriginalGroupInformation() *iso20022.OriginalGroupInformation22

func (f *FIToFIPaymentReversalV02) AddTransactionInformation() *iso20022.PaymentTransactionInformation29

type FIToFIPaymentReversalV03 ¶

type FIToFIPaymentReversalV03 struct {

	// Set of characteristics shared by all individual transactions included in the message.
	GroupHeader *iso20022.GroupHeader57 `xml:"GrpHdr"`

	// Information concerning the original group of transactions, to which the message refers.
	OriginalGroupInformation *iso20022.OriginalGroupHeader3 `xml:"OrgnlGrpInf"`

	// Information concerning the original transactions, to which the reversal message refers.
	TransactionInformation []*iso20022.PaymentTransaction36 `xml:"TxInf,omitempty"`

	// Additional information that cannot be captured in the structured elements and/or any other specific block.
	SupplementaryData []*iso20022.SupplementaryData1 `xml:"SplmtryData,omitempty"`
}

Scope The FinancialInstitutionToFinancialInstitutionPaymentReversal message is sent by an agent to the next party in the payment chain. It is used to reverse a payment previously executed. Usage The FIToFIPaymentReversal message is exchanged between agents to reverse a FIToFICustomerDirectDebit message that has been settled. The result will be a credit on the debtor account. The FIToFIPaymentReversal message may or may not be the follow-up of a CustomerDirectDebitInitiation message. The FIToFIPaymentReversal message refers to the original FIToFICustomerDirectDebit message by means of references only or by means of references and a set of elements from the original instruction. The FIToFIPaymentReversal message can be used in domestic and cross-border scenarios.

func (f *FIToFIPaymentReversalV03) AddGroupHeader() *iso20022.GroupHeader57

func (f *FIToFIPaymentReversalV03) AddOriginalGroupInformation() *iso20022.OriginalGroupHeader3

func (f *FIToFIPaymentReversalV03) AddSupplementaryData() *iso20022.SupplementaryData1

func (f *FIToFIPaymentReversalV03) AddTransactionInformation() *iso20022.PaymentTransaction36

type FIToFIPaymentReversalV04 ¶

type FIToFIPaymentReversalV04 struct {

	// Set of characteristics shared by all individual transactions included in the message.
	GroupHeader *iso20022.GroupHeader57 `xml:"GrpHdr"`

	// Information concerning the original group of transactions, to which the message refers.
	OriginalGroupInformation *iso20022.OriginalGroupHeader3 `xml:"OrgnlGrpInf"`

	// Information concerning the original transactions, to which the reversal message refers.
	TransactionInformation []*iso20022.PaymentTransaction45 `xml:"TxInf,omitempty"`

	// Additional information that cannot be captured in the structured elements and/or any other specific block.
	SupplementaryData []*iso20022.SupplementaryData1 `xml:"SplmtryData,omitempty"`
}

Scope The FinancialInstitutionToFinancialInstitutionPaymentReversal message is sent by an agent to the next party in the payment chain. It is used to reverse a payment previously executed. Usage The FIToFIPaymentReversal message is exchanged between agents to reverse a payment message that has been settled. The result will be a credit on the debtor account (when the reversed payment was a Direct Debit) or a debit on the creditor account (when the reversed payment was a Credit Transfer). The FIToFIPaymentReversal message may or may not be the follow-up of a payment message. The FIToFIPaymentReversal message refers to the original payment message by means of references only or by means of references and a set of elements from the original instruction. The FIToFIPaymentReversal message can be used in domestic and cross-border scenarios.

func (f *FIToFIPaymentReversalV04) AddGroupHeader() *iso20022.GroupHeader57

func (f *FIToFIPaymentReversalV04) AddOriginalGroupInformation() *iso20022.OriginalGroupHeader3

func (f *FIToFIPaymentReversalV04) AddSupplementaryData() *iso20022.SupplementaryData1

func (f *FIToFIPaymentReversalV04) AddTransactionInformation() *iso20022.PaymentTransaction45

type FIToFIPaymentReversalV05 ¶

type FIToFIPaymentReversalV05 struct {

	// Set of characteristics shared by all individual transactions included in the message.
	GroupHeader *iso20022.GroupHeader57 `xml:"GrpHdr"`

	// Information concerning the original group of transactions, to which the message refers.
	OriginalGroupInformation *iso20022.OriginalGroupHeader3 `xml:"OrgnlGrpInf,omitempty"`

	// Information concerning the original transactions, to which the reversal message refers.
	TransactionInformation []*iso20022.PaymentTransaction51 `xml:"TxInf,omitempty"`

	// Additional information that cannot be captured in the structured elements and/or any other specific block.
	SupplementaryData []*iso20022.SupplementaryData1 `xml:"SplmtryData,omitempty"`
}

Scope The FinancialInstitutionToFinancialInstitutionPaymentReversal message is sent by an agent to the next party in the payment chain. It is used to reverse a payment previously executed. Usage The FIToFIPaymentReversal message is exchanged between agents to reverse a payment message that has been settled. The result will be a credit on the debtor account (when the reversed payment was a Direct Debit) or a debit on the creditor account (when the reversed payment was a Credit Transfer). The FIToFIPaymentReversal message may or may not be the follow-up of a payment message. The FIToFIPaymentReversal message refers to the original payment message by means of references only or by means of references and a set of elements from the original instruction. The FIToFIPaymentReversal message can be used in domestic and cross-border scenarios.

func (f *FIToFIPaymentReversalV05) AddGroupHeader() *iso20022.GroupHeader57

func (f *FIToFIPaymentReversalV05) AddOriginalGroupInformation() *iso20022.OriginalGroupHeader3

func (f *FIToFIPaymentReversalV05) AddSupplementaryData() *iso20022.SupplementaryData1

func (f *FIToFIPaymentReversalV05) AddTransactionInformation() *iso20022.PaymentTransaction51

type FIToFIPaymentReversalV06 ¶

type FIToFIPaymentReversalV06 struct {

	// Set of characteristics shared by all individual transactions included in the message.
	GroupHeader *iso20022.GroupHeader71 `xml:"GrpHdr"`

	// Information concerning the original group of transactions, to which the message refers.
	OriginalGroupInformation *iso20022.OriginalGroupHeader3 `xml:"OrgnlGrpInf,omitempty"`

	// Information concerning the original transactions, to which the reversal message refers.
	TransactionInformation []*iso20022.PaymentTransaction60 `xml:"TxInf,omitempty"`

	// Additional information that cannot be captured in the structured elements and/or any other specific block.
	SupplementaryData []*iso20022.SupplementaryData1 `xml:"SplmtryData,omitempty"`
}

Scope The FinancialInstitutionToFinancialInstitutionPaymentReversal message is sent by an agent to the next party in the payment chain. It is used to reverse a payment previously executed. Usage The FIToFIPaymentReversal message is exchanged between agents to reverse a payment message that has been settled. The result will be a credit on the debtor account (when the reversed payment was a Direct Debit) or a debit on the creditor account (when the reversed payment was a Credit Transfer). The FIToFIPaymentReversal message may or may not be the follow-up of a payment message. The FIToFIPaymentReversal message refers to the original payment message by means of references only or by means of references and a set of elements from the original instruction. The FIToFIPaymentReversal message can be used in domestic and cross-border scenarios.

func (f *FIToFIPaymentReversalV06) AddGroupHeader() *iso20022.GroupHeader71

func (f *FIToFIPaymentReversalV06) AddOriginalGroupInformation() *iso20022.OriginalGroupHeader3

func (f *FIToFIPaymentReversalV06) AddSupplementaryData() *iso20022.SupplementaryData1

func (f *FIToFIPaymentReversalV06) AddTransactionInformation() *iso20022.PaymentTransaction60

type FIToFIPaymentReversalV07 ¶

type FIToFIPaymentReversalV07 struct {

	// Set of characteristics shared by all individual transactions included in the message.
	GroupHeader *iso20022.GroupHeader71 `xml:"GrpHdr"`

	// Information concerning the original group of transactions, to which the message refers.
	OriginalGroupInformation *iso20022.OriginalGroupHeader3 `xml:"OrgnlGrpInf,omitempty"`

	// Information concerning the original transactions, to which the reversal message refers.
	TransactionInformation []*iso20022.PaymentTransaction81 `xml:"TxInf,omitempty"`

	// Additional information that cannot be captured in the structured elements and/or any other specific block.
	SupplementaryData []*iso20022.SupplementaryData1 `xml:"SplmtryData,omitempty"`
}

Scope The FinancialInstitutionToFinancialInstitutionPaymentReversal message is sent by an agent to the next party in the payment chain. It is used to reverse a payment previously executed. Usage The FIToFIPaymentReversal message is exchanged between agents to reverse a payment message that has been settled. The result will be a credit on the debtor account (when the reversed payment was a Direct Debit) or a debit on the creditor account (when the reversed payment was a Credit Transfer). The FIToFIPaymentReversal message may or may not be the follow-up of a payment message. The FIToFIPaymentReversal message refers to the original payment message by means of references only or by means of references and a set of elements from the original instruction. The FIToFIPaymentReversal message can be used in domestic and cross-border scenarios.

func (f *FIToFIPaymentReversalV07) AddGroupHeader() *iso20022.GroupHeader71

func (f *FIToFIPaymentReversalV07) AddOriginalGroupInformation() *iso20022.OriginalGroupHeader3

func (f *FIToFIPaymentReversalV07) AddSupplementaryData() *iso20022.SupplementaryData1

func (f *FIToFIPaymentReversalV07) AddTransactionInformation() *iso20022.PaymentTransaction81

type FIToFIPaymentStatusReportV03 ¶

type FIToFIPaymentStatusReportV03 struct {

	// Set of characteristics shared by all individual transactions included in the status report message.
	GroupHeader *iso20022.GroupHeader37 `xml:"GrpHdr"`

	// Original group information concerning the group of transactions, to which the status report message refers to.
	OriginalGroupInformationAndStatus *iso20022.OriginalGroupInformation20 `xml:"OrgnlGrpInfAndSts"`

	// Information concerning the original transactions, to which the status report message refers.
	TransactionInformationAndStatus []*iso20022.PaymentTransactionInformation26 `xml:"TxInfAndSts,omitempty"`
}

Scope The FinancialInstitutionToFinancialInstitutionPaymentStatusReport message is sent by an instructed agent to the previous party in the payment chain. It is used to inform this party about the positive or negative status of an instruction (either single or file). It is also used to report on a pending instruction. Usage The FIToFIPaymentStatusReport message is exchanged between agents to provide status information about instructions previously sent. Its usage will always be governed by a bilateral agreement between the agents. The FIToFIPaymentStatusReport message can be used to provide information about the status (e.g. rejection, acceptance) of a credit transfer instruction, a direct debit instruction, as well as other intra-agent instructions (for example FIToFIPaymentCancellationRequest). The FIToFIPaymentStatusReport message refers to the original instruction(s) by means of references only or by means of references and a set of elements from the original instruction. The FIToFIPaymentStatusReport message can be used in domestic and cross-border scenarios.

func (f *FIToFIPaymentStatusReportV03) AddGroupHeader() *iso20022.GroupHeader37

func (f *FIToFIPaymentStatusReportV03) AddOriginalGroupInformationAndStatus() *iso20022.OriginalGroupInformation20

func (f *FIToFIPaymentStatusReportV03) AddTransactionInformationAndStatus() *iso20022.PaymentTransactionInformation26

type FIToFIPaymentStatusReportV04 ¶

type FIToFIPaymentStatusReportV04 struct {

	// Set of characteristics shared by all individual transactions included in the status report message.
	GroupHeader *iso20022.GroupHeader53 `xml:"GrpHdr"`

	// Original group information concerning the group of transactions, to which the status report message refers to.
	OriginalGroupInformationAndStatus *iso20022.OriginalGroupHeader1 `xml:"OrgnlGrpInfAndSts"`

	// Information concerning the original transactions, to which the status report message refers.
	TransactionInformationAndStatus []*iso20022.PaymentTransaction33 `xml:"TxInfAndSts,omitempty"`

	// Additional information that cannot be captured in the structured elements and/or any other specific block.
	SupplementaryData []*iso20022.SupplementaryData1 `xml:"SplmtryData,omitempty"`
}

Scope The FinancialInstitutionToFinancialInstitutionPaymentStatusReport message is sent by an instructed agent to the previous party in the payment chain. It is used to inform this party about the positive or negative status of an instruction (either single or file). It is also used to report on a pending instruction. Usage The FIToFIPaymentStatusReport message is exchanged between agents to provide status information about instructions previously sent. Its usage will always be governed by a bilateral agreement between the agents. The FIToFIPaymentStatusReport message can be used to provide information about the status (e.g. rejection, acceptance) of a credit transfer instruction, a direct debit instruction, as well as other intra-agent instructions (for example FIToFIPaymentCancellationRequest). The FIToFIPaymentStatusReport message refers to the original instruction(s) by means of references only or by means of references and a set of elements from the original instruction. The FIToFIPaymentStatusReport message can be used in domestic and cross-border scenarios.

func (f *FIToFIPaymentStatusReportV04) AddGroupHeader() *iso20022.GroupHeader53

func (f *FIToFIPaymentStatusReportV04) AddOriginalGroupInformationAndStatus() *iso20022.OriginalGroupHeader1

func (f *FIToFIPaymentStatusReportV04) AddSupplementaryData() *iso20022.SupplementaryData1

func (f *FIToFIPaymentStatusReportV04) AddTransactionInformationAndStatus() *iso20022.PaymentTransaction33

type FIToFIPaymentStatusReportV05 ¶

type FIToFIPaymentStatusReportV05 struct {

	// Set of characteristics shared by all individual transactions included in the status report message.
	GroupHeader *iso20022.GroupHeader53 `xml:"GrpHdr"`

	// Original group information concerning the group of transactions, to which the status report message refers to.
	OriginalGroupInformationAndStatus *iso20022.OriginalGroupHeader1 `xml:"OrgnlGrpInfAndSts"`

	// Information concerning the original transactions, to which the status report message refers.
	TransactionInformationAndStatus []*iso20022.PaymentTransaction43 `xml:"TxInfAndSts,omitempty"`

	// Additional information that cannot be captured in the structured elements and/or any other specific block.
	SupplementaryData []*iso20022.SupplementaryData1 `xml:"SplmtryData,omitempty"`
}

Scope The FinancialInstitutionToFinancialInstitutionPaymentStatusReport message is sent by an instructed agent to the previous party in the payment chain. It is used to inform this party about the positive or negative status of an instruction (either single or file). It is also used to report on a pending instruction. Usage The FIToFIPaymentStatusReport message is exchanged between agents to provide status information about instructions previously sent. Its usage will always be governed by a bilateral agreement between the agents. The FIToFIPaymentStatusReport message can be used to provide information about the status (e.g. rejection, acceptance) of a credit transfer instruction, a direct debit instruction, as well as other intra-agent instructions (for example FIToFIPaymentCancellationRequest). The FIToFIPaymentStatusReport message refers to the original instruction(s) by means of references only or by means of references and a set of elements from the original instruction. The FIToFIPaymentStatusReport message can be used in domestic and cross-border scenarios.

func (f *FIToFIPaymentStatusReportV05) AddGroupHeader() *iso20022.GroupHeader53

func (f *FIToFIPaymentStatusReportV05) AddOriginalGroupInformationAndStatus() *iso20022.OriginalGroupHeader1

func (f *FIToFIPaymentStatusReportV05) AddSupplementaryData() *iso20022.SupplementaryData1

func (f *FIToFIPaymentStatusReportV05) AddTransactionInformationAndStatus() *iso20022.PaymentTransaction43

type FIToFIPaymentStatusReportV06 ¶

type FIToFIPaymentStatusReportV06 struct {

	// Set of characteristics shared by all individual transactions included in the status report message.
	GroupHeader *iso20022.GroupHeader53 `xml:"GrpHdr"`

	// Original group information concerning the group of transactions, to which the status report message refers to.
	OriginalGroupInformationAndStatus []*iso20022.OriginalGroupHeader1 `xml:"OrgnlGrpInfAndSts,omitempty"`

	// Information concerning the original transactions, to which the status report message refers.
	TransactionInformationAndStatus []*iso20022.PaymentTransaction52 `xml:"TxInfAndSts,omitempty"`

	// Additional information that cannot be captured in the structured elements and/or any other specific block.
	SupplementaryData []*iso20022.SupplementaryData1 `xml:"SplmtryData,omitempty"`
}

Scope The FinancialInstitutionToFinancialInstitutionPaymentStatusReport message is sent by an instructed agent to the previous party in the payment chain. It is used to inform this party about the positive or negative status of an instruction (either single or file). It is also used to report on a pending instruction. Usage The FIToFIPaymentStatusReport message is exchanged between agents to provide status information about instructions previously sent. Its usage will always be governed by a bilateral agreement between the agents. The FIToFIPaymentStatusReport message can be used to provide information about the status (e.g. rejection, acceptance) of a credit transfer instruction, a direct debit instruction, as well as other intra-agent instructions (for example FIToFIPaymentCancellationRequest). The FIToFIPaymentStatusReport message refers to the original instruction(s) by means of references only or by means of references and a set of elements from the original instruction. The FIToFIPaymentStatusReport message can be used in domestic and cross-border scenarios.

func (f *FIToFIPaymentStatusReportV06) AddGroupHeader() *iso20022.GroupHeader53

func (f *FIToFIPaymentStatusReportV06) AddOriginalGroupInformationAndStatus() *iso20022.OriginalGroupHeader1

func (f *FIToFIPaymentStatusReportV06) AddSupplementaryData() *iso20022.SupplementaryData1

func (f *FIToFIPaymentStatusReportV06) AddTransactionInformationAndStatus() *iso20022.PaymentTransaction52

type FIToFIPaymentStatusReportV07 ¶

type FIToFIPaymentStatusReportV07 struct {

	// Set of characteristics shared by all individual transactions included in the status report message.
	GroupHeader *iso20022.GroupHeader53 `xml:"GrpHdr"`

	// Original group information concerning the group of transactions, to which the status report message refers to.
	OriginalGroupInformationAndStatus []*iso20022.OriginalGroupHeader1 `xml:"OrgnlGrpInfAndSts,omitempty"`

	// Information concerning the original transactions, to which the status report message refers.
	TransactionInformationAndStatus []*iso20022.PaymentTransaction63 `xml:"TxInfAndSts,omitempty"`

	// Additional information that cannot be captured in the structured elements and/or any other specific block.
	SupplementaryData []*iso20022.SupplementaryData1 `xml:"SplmtryData,omitempty"`
}

Scope The FinancialInstitutionToFinancialInstitutionPaymentStatusReport message is sent by an instructed agent to the previous party in the payment chain. It is used to inform this party about the positive or negative status of an instruction (either single or file). It is also used to report on a pending instruction. Usage The FIToFIPaymentStatusReport message is exchanged between agents to provide status information about instructions previously sent. Its usage will always be governed by a bilateral agreement between the agents. The FIToFIPaymentStatusReport message can be used to provide information about the status (e.g. rejection, acceptance) of a credit transfer instruction, a direct debit instruction, as well as other intra-agent instructions (for example FIToFIPaymentCancellationRequest). The FIToFIPaymentStatusReport message refers to the original instruction(s) by means of references only or by means of references and a set of elements from the original instruction. The FIToFIPaymentStatusReport message can be used in domestic and cross-border scenarios.

func (f *FIToFIPaymentStatusReportV07) AddGroupHeader() *iso20022.GroupHeader53

func (f *FIToFIPaymentStatusReportV07) AddOriginalGroupInformationAndStatus() *iso20022.OriginalGroupHeader1

func (f *FIToFIPaymentStatusReportV07) AddSupplementaryData() *iso20022.SupplementaryData1

func (f *FIToFIPaymentStatusReportV07) AddTransactionInformationAndStatus() *iso20022.PaymentTransaction63

type FIToFIPaymentStatusReportV08 ¶

type FIToFIPaymentStatusReportV08 struct {

	// Set of characteristics shared by all individual transactions included in the status report message.
	GroupHeader *iso20022.GroupHeader53 `xml:"GrpHdr"`

	// Original group information concerning the group of transactions, to which the status report message refers to.
	OriginalGroupInformationAndStatus []*iso20022.OriginalGroupHeader7 `xml:"OrgnlGrpInfAndSts,omitempty"`

	// Information concerning the original transactions, to which the status report message refers.
	TransactionInformationAndStatus []*iso20022.PaymentTransaction80 `xml:"TxInfAndSts,omitempty"`

	// Additional information that cannot be captured in the structured elements and/or any other specific block.
	SupplementaryData []*iso20022.SupplementaryData1 `xml:"SplmtryData,omitempty"`
}

Scope The FIToFIPaymentStatusReport message is sent by an instructed agent to the previous party in the payment chain. It is used to inform this party about the positive or negative status of an instruction (either single or file). It is also used to report on a pending instruction. Usage The FIToFIPaymentStatusReport message is exchanged between agents to provide status information about instructions previously sent. Its usage will always be governed by a bilateral agreement between the agents. The FIToFIPaymentStatusReport message can be used to provide information about the status (e.g. rejection, acceptance) of a credit transfer instruction, a direct debit instruction, as well as other intra-agent instructions (for example FIToFIPaymentCancellationRequest). The FIToFIPaymentStatusReport message refers to the original instruction(s) by means of references only or by means of references and a set of elements from the original instruction. The FIToFIPaymentStatusReport message can be used in domestic and cross-border scenarios. The FIToFIPaymentStatusReport may also be sent to the receiver of the payment in a real time payment scenario, as both sides of the transactions must be informed of the status of the transaction (e.g. either the beneficiary is credited, or the transaction is rejected).

func (f *FIToFIPaymentStatusReportV08) AddGroupHeader() *iso20022.GroupHeader53

func (f *FIToFIPaymentStatusReportV08) AddOriginalGroupInformationAndStatus() *iso20022.OriginalGroupHeader7

func (f *FIToFIPaymentStatusReportV08) AddSupplementaryData() *iso20022.SupplementaryData1

func (f *FIToFIPaymentStatusReportV08) AddTransactionInformationAndStatus() *iso20022.PaymentTransaction80

type FIToFIPaymentStatusRequestV01 ¶

type FIToFIPaymentStatusRequestV01 struct {

	// Set of characteristics shared by all individual transactions included in the status request message.
	GroupHeader *iso20022.GroupHeader53 `xml:"GrpHdr"`

	// Original group information concerning the group of transactions, to which the status request message refers to.
	OriginalGroupInformation []*iso20022.OriginalGroupInformation27 `xml:"OrgnlGrpInf,omitempty"`

	// Information concerning the original transaction, to which the status request message refers.
	TransactionInformation []*iso20022.PaymentTransaction73 `xml:"TxInf,omitempty"`

	// Additional information that cannot be captured in the structured elements and/or any other specific block.
	SupplementaryData []*iso20022.SupplementaryData1 `xml:"SplmtryData,omitempty"`
}

Scope The FinancialInstitutionToFinancialInstitutionPaymentStatusRequest message is sent by the debtor agent to the creditor agent, directly or through other agents and/or a payment clearing and settlement system. It is used to request a FIToFIPaymentStatusReport message containing information on the status of a previously sent instruction. Usage The FIToFIPaymentStatusRequest message is exchanged between agents to request status information about instructions previously sent. Its usage will always be governed by a bilateral agreement between the agents. The FIToFIPaymentStatusRequest message can be used to request information about the status (e.g. rejection, acceptance) of a credit transfer instruction, a direct debit instruction, as well as other intra-agent instructions (for example FIToFIPaymentCancellationRequest). The FIToFIPaymentStatusRequest message refers to the original instruction(s) by means of references only or by means of references and a set of elements from the original instruction. The FIToFIPaymentStatusRequest message can be used in domestic and cross-border scenarios.

func (f *FIToFIPaymentStatusRequestV01) AddGroupHeader() *iso20022.GroupHeader53

func (f *FIToFIPaymentStatusRequestV01) AddOriginalGroupInformation() *iso20022.OriginalGroupInformation27

func (f *FIToFIPaymentStatusRequestV01) AddSupplementaryData() *iso20022.SupplementaryData1

func (f *FIToFIPaymentStatusRequestV01) AddTransactionInformation() *iso20022.PaymentTransaction73

type FinancialInstitutionCreditTransferV01 ¶

type FinancialInstitutionCreditTransferV01 struct {

	// Set of characteristics shared by all individual transactions included in the message.
	GroupHeader *iso20022.GroupHeader4 `xml:"GrpHdr"`

	// Set of elements providing information specific to the individual credit transfer(s).
	CreditTransferTransactionInformation []*iso20022.CreditTransferTransactionInformation3 `xml:"CdtTrfTxInf"`
}

Scope The FinancialInstitutionCreditTransfer message is sent by a debtor financial institution to a creditor financial institution, directly or through other agents and/or a payment clearing and settlement system. It is used to move funds from a debtor account to a creditor, where both debtor and creditor are financial institutions. Usage The FinancialInstitutionCreditTransfer message is exchanged between agents and can contain one or more credit transfer instructions where debtor and creditor are both financial institutions. The FinancialInstitutionCreditTransfer message does not allow for grouping: a CreditTransferTransactionInformation block must be present for each credit transfer transaction. The FinancialInstitutionCreditTransfer message can be used in domestic and cross-border scenarios.

func (f *FinancialInstitutionCreditTransferV01) AddCreditTransferTransactionInformation() *iso20022.CreditTransferTransactionInformation3

func (f *FinancialInstitutionCreditTransferV01) AddGroupHeader() *iso20022.GroupHeader4

type FinancialInstitutionCreditTransferV02 ¶

type FinancialInstitutionCreditTransferV02 struct {

	// Set of characteristics shared by all individual transactions included in the message.
	GroupHeader *iso20022.GroupHeader35 `xml:"GrpHdr"`

	// Set of elements providing information specific to the individual credit transfer(s).
	CreditTransferTransactionInformation []*iso20022.CreditTransferTransactionInformation13 `xml:"CdtTrfTxInf"`
}

Scope The FinancialInstitutionCreditTransfer message is sent by a debtor financial institution to a creditor financial institution, directly or through other agents and/or a payment clearing and settlement system. It is used to move funds from a debtor account to a creditor, where both debtor and creditor are financial institutions. Usage The FinancialInstitutionCreditTransfer message is exchanged between agents and can contain one or more credit transfer instructions where debtor and creditor are both financial institutions. The FinancialInstitutionCreditTransfer message does not allow for grouping: a CreditTransferTransactionInformation block must be present for each credit transfer transaction. The FinancialInstitutionCreditTransfer message can be used in domestic and cross-border scenarios.

func (f *FinancialInstitutionCreditTransferV02) AddCreditTransferTransactionInformation() *iso20022.CreditTransferTransactionInformation13

func (f *FinancialInstitutionCreditTransferV02) AddGroupHeader() *iso20022.GroupHeader35

type FinancialInstitutionCreditTransferV03 ¶

type FinancialInstitutionCreditTransferV03 struct {

	// Set of characteristics shared by all individual transactions included in the message.
	GroupHeader *iso20022.GroupHeader51 `xml:"GrpHdr"`

	// Set of elements providing information specific to the individual credit transfer(s).
	CreditTransferTransactionInformation []*iso20022.CreditTransferTransaction4 `xml:"CdtTrfTxInf"`

	// Additional information that cannot be captured in the structured elements and/or any other specific block.
	SupplementaryData []*iso20022.SupplementaryData1 `xml:"SplmtryData,omitempty"`
}

Scope The FinancialInstitutionCreditTransfer message is sent by a debtor financial institution to a creditor financial institution, directly or through other agents and/or a payment clearing and settlement system. It is used to move funds from a debtor account to a creditor, where both debtor and creditor are financial institutions. Usage The FinancialInstitutionCreditTransfer message is exchanged between agents and can contain one or more credit transfer instructions where debtor and creditor are both financial institutions. The FinancialInstitutionCreditTransfer message does not allow for grouping: a CreditTransferTransactionInformation block must be present for each credit transfer transaction. The FinancialInstitutionCreditTransfer message can be used in domestic and cross-border scenarios.

func (f *FinancialInstitutionCreditTransferV03) AddCreditTransferTransactionInformation() *iso20022.CreditTransferTransaction4

func (f *FinancialInstitutionCreditTransferV03) AddGroupHeader() *iso20022.GroupHeader51

func (f *FinancialInstitutionCreditTransferV03) AddSupplementaryData() *iso20022.SupplementaryData1

type FinancialInstitutionCreditTransferV04 ¶

type FinancialInstitutionCreditTransferV04 struct {

	// Set of characteristics shared by all individual transactions included in the message.
	GroupHeader *iso20022.GroupHeader49 `xml:"GrpHdr"`

	// Set of elements providing information specific to the individual credit transfer(s).
	CreditTransferTransactionInformation []*iso20022.CreditTransferTransaction8 `xml:"CdtTrfTxInf"`

	// Additional information that cannot be captured in the structured elements and/or any other specific block.
	SupplementaryData []*iso20022.SupplementaryData1 `xml:"SplmtryData,omitempty"`
}

Scope The FinancialInstitutionCreditTransfer message is sent by a debtor financial institution to a creditor financial institution, directly or through other agents and/or a payment clearing and settlement system. It is used to move funds from a debtor account to a creditor, where both debtor and creditor are financial institutions. Usage The FinancialInstitutionCreditTransfer message is exchanged between agents and can contain one or more credit transfer instructions where debtor and creditor are both financial institutions. The FinancialInstitutionCreditTransfer message does not allow for grouping: a CreditTransferTransactionInformation block must be present for each credit transfer transaction. The FinancialInstitutionCreditTransfer message can be used in domestic and cross-border scenarios.

func (f *FinancialInstitutionCreditTransferV04) AddCreditTransferTransactionInformation() *iso20022.CreditTransferTransaction8

func (f *FinancialInstitutionCreditTransferV04) AddGroupHeader() *iso20022.GroupHeader49

func (f *FinancialInstitutionCreditTransferV04) AddSupplementaryData() *iso20022.SupplementaryData1

type FinancialInstitutionCreditTransferV05 ¶

type FinancialInstitutionCreditTransferV05 struct {

	// Set of characteristics shared by all individual transactions included in the message.
	GroupHeader *iso20022.GroupHeader49 `xml:"GrpHdr"`

	// Set of elements providing information specific to the individual credit transfer(s).
	CreditTransferTransactionInformation []*iso20022.CreditTransferTransaction17 `xml:"CdtTrfTxInf"`

	// Additional information that cannot be captured in the structured elements and/or any other specific block.
	SupplementaryData []*iso20022.SupplementaryData1 `xml:"SplmtryData,omitempty"`
}

Scope The FinancialInstitutionCreditTransfer message is sent by a debtor financial institution to a creditor financial institution, directly or through other agents and/or a payment clearing and settlement system. It is used to move funds from a debtor account to a creditor, where both debtor and creditor are financial institutions. Usage The FinancialInstitutionCreditTransfer message is exchanged between agents and can contain one or more credit transfer instructions where debtor and creditor are both financial institutions. The FinancialInstitutionCreditTransfer message does not allow for grouping: a CreditTransferTransactionInformation block must be present for each credit transfer transaction. The FinancialInstitutionCreditTransfer message can be used in domestic and cross-border scenarios.

func (f *FinancialInstitutionCreditTransferV05) AddCreditTransferTransactionInformation() *iso20022.CreditTransferTransaction17

func (f *FinancialInstitutionCreditTransferV05) AddGroupHeader() *iso20022.GroupHeader49

func (f *FinancialInstitutionCreditTransferV05) AddSupplementaryData() *iso20022.SupplementaryData1

type FinancialInstitutionCreditTransferV06 ¶

type FinancialInstitutionCreditTransferV06 struct {

	// Set of characteristics shared by all individual transactions included in the message.
	GroupHeader *iso20022.GroupHeader70 `xml:"GrpHdr"`

	// Set of elements providing information specific to the individual credit transfer(s).
	CreditTransferTransactionInformation []*iso20022.CreditTransferTransaction23 `xml:"CdtTrfTxInf"`

	// Additional information that cannot be captured in the structured elements and/or any other specific block.
	SupplementaryData []*iso20022.SupplementaryData1 `xml:"SplmtryData,omitempty"`
}

Scope The FinancialInstitutionCreditTransfer message is sent by a debtor financial institution to a creditor financial institution, directly or through other agents and/or a payment clearing and settlement system. It is used to move funds from a debtor account to a creditor, where both debtor and creditor are financial institutions. Usage The FinancialInstitutionCreditTransfer message is exchanged between agents and can contain one or more credit transfer instructions where debtor and creditor are both financial institutions. The FinancialInstitutionCreditTransfer message does not allow for grouping: a CreditTransferTransactionInformation block must be present for each credit transfer transaction. The FinancialInstitutionCreditTransfer message can be used in domestic and cross-border scenarios.

func (f *FinancialInstitutionCreditTransferV06) AddCreditTransferTransactionInformation() *iso20022.CreditTransferTransaction23

func (f *FinancialInstitutionCreditTransferV06) AddGroupHeader() *iso20022.GroupHeader70

func (f *FinancialInstitutionCreditTransferV06) AddSupplementaryData() *iso20022.SupplementaryData1

type FinancialInstitutionDirectDebitV02 ¶

type FinancialInstitutionDirectDebitV02 struct {

	// Common characteristics for all individual transactions included in the message.
	GroupHeader *iso20022.GroupHeader63 `xml:"GrpHdr"`

	// Characteristics that apply to the credit side of the payment transaction(s) included in the message.
	CreditInstruction []*iso20022.CreditTransferTransaction9 `xml:"CdtInstr"`

	// Additional information that cannot be captured in the structured elements and/or any other specific block.
	SupplementaryData []*iso20022.SupplementaryData1 `xml:"SplmtryData,omitempty"`
}

Scope: The FinancialInstitutionDirectDebit message is sent by an exchange or clearing house, or a financial institution, directly or through another agent, to the DebtorAgent. It is used to instruct the DebtorAgent to move funds from one or more debtor(s) account(s) to one or more creditor(s), where both debtor and creditor are financial institutions.

Usage: The FinancialInstitutionDirectDebit message is exchanged between agents and can contain one or more financial institution direct debit instruction(s) for one or more creditor(s). The FinancialInstitutionDirectDebit message can be used in domestic and cross-border scenarios.

func (f *FinancialInstitutionDirectDebitV02) AddCreditInstruction() *iso20022.CreditTransferTransaction9

func (f *FinancialInstitutionDirectDebitV02) AddGroupHeader() *iso20022.GroupHeader63

func (f *FinancialInstitutionDirectDebitV02) AddSupplementaryData() *iso20022.SupplementaryData1

type PaymentCancellationRequestV01 ¶

type PaymentCancellationRequestV01 struct {

	// Set of characteristics shared by all individual transactions included in the message.
	GroupHeader *iso20022.GroupHeader7 `xml:"GrpHdr"`

	// Information concerning the original group of transactions, to which the message refers.
	OriginalGroupInformation *iso20022.OriginalGroupInformation4 `xml:"OrgnlGrpInf"`

	// Information concerning the original transactions, to which the cancellation request message refers.
	TransactionInformation []*iso20022.PaymentTransactionInformation3 `xml:"TxInf,omitempty"`
}

Scope The PaymentCancellationRequest message is sent by the initiating party or any agent, to the next party in the payment chain. It is used to request the cancellation of an instruction previously sent. Usage The PaymentCancellationRequest message is exchanged between agents to request the cancellation of a payment message previously sent (i.e. FIToFICustomerCreditTransfer, FIToFICustomerDirectDebit, and FinancialInstitutionCreditTransfer). The PaymentCancellationRequest message can be used to request the cancellation of single instructions or multiple instructions, from one or multiple files. The PaymentCancellationRequest message can be used in domestic and cross-border scenarios. The PaymentCancellationRequest message refers to the original instruction(s) by means of references only or by means of references and a set of elements from the original instruction. The PaymentCancellationRequest message exchanged between agents is identified in the schema as follows: urn:iso:std:iso:20022:tech:xsd:pacs.006.001.01

func (p *PaymentCancellationRequestV01) AddGroupHeader() *iso20022.GroupHeader7

func (p *PaymentCancellationRequestV01) AddOriginalGroupInformation() *iso20022.OriginalGroupInformation4

func (p *PaymentCancellationRequestV01) AddTransactionInformation() *iso20022.PaymentTransactionInformation3

type PaymentReturnV01 ¶

type PaymentReturnV01 struct {

	// Set of characteristics shared by all individual transactions included in the message.
	GroupHeader *iso20022.GroupHeader6 `xml:"GrpHdr"`

	// Information concerning the original group of transactions, to which the message refers.
	OriginalGroupInformation *iso20022.OriginalGroupInformation2 `xml:"OrgnlGrpInf,omitempty"`

	// Information concerning the original transactions, to which the return message refers.
	TransactionInformation []*iso20022.PaymentTransactionInformation2 `xml:"TxInf,omitempty"`
}

Scope The PaymentReturn message is sent by an agent to the previous agent in the payment chain to undo a payment previously settled. Usage The PaymentReturn message is exchanged between agents to return funds after settlement of credit transfer instructions (i.e. FIToFICustomerCreditTransfer message and FinancialInstitutionCreditTransfer message) or direct debit instructions (FIToFICustomerDirectDebit message). The PaymentReturn message should not be used between agents and non-financial institution customers. Non-financial institution customers will be informed about a debit or a credit on their account(s) through an Advice of Credit/Debit message and/or Statement message. The PaymentReturn message can be used to return single instructions or multiple instructions from one or different files. The PaymentReturn message can be used in domestic and cross-border scenarios. The PaymentReturn message refers to the original instruction(s) by means of references only or by means of references and a set of elements from the original instruction.

func (p *PaymentReturnV01) AddGroupHeader() *iso20022.GroupHeader6

func (p *PaymentReturnV01) AddOriginalGroupInformation() *iso20022.OriginalGroupInformation2

func (p *PaymentReturnV01) AddTransactionInformation() *iso20022.PaymentTransactionInformation2

type PaymentReturnV02 ¶

type PaymentReturnV02 struct {

	// Set of characteristics shared by all individual transactions included in the message.
	GroupHeader *iso20022.GroupHeader38 `xml:"GrpHdr"`

	// Information concerning the original group of transactions, to which the message refers.
	OriginalGroupInformation *iso20022.OriginalGroupInformation21 `xml:"OrgnlGrpInf,omitempty"`

	// Information concerning the original transactions, to which the return message refers.
	TransactionInformation []*iso20022.PaymentTransactionInformation27 `xml:"TxInf,omitempty"`
}

Scope The PaymentReturn message is sent by an agent to the previous agent in the payment chain to undo a payment previously settled. Usage The PaymentReturn message is exchanged between agents to return funds after settlement of credit transfer instructions (i.e. FIToFICustomerCreditTransfer message and FinancialInstitutionCreditTransfer message) or direct debit instructions (FIToFICustomerDirectDebit message). The PaymentReturn message should not be used between agents and non-financial institution customers. Non-financial institution customers will be informed about a debit or a credit on their account(s) through a BankToCustomerDebitCreditNotification message ('notification') and/or BankToCustomerAccountReport/BankToCustomerStatement message ('statement'). The PaymentReturn message can be used to return single instructions or multiple instructions from one or different files. The PaymentReturn message can be used in domestic and cross-border scenarios. The PaymentReturn message refers to the original instruction(s) by means of references only or by means of references and a set of elements from the original instruction.

func (p *PaymentReturnV02) AddGroupHeader() *iso20022.GroupHeader38

func (p *PaymentReturnV02) AddOriginalGroupInformation() *iso20022.OriginalGroupInformation21

func (p *PaymentReturnV02) AddTransactionInformation() *iso20022.PaymentTransactionInformation27

type PaymentReturnV03 ¶

type PaymentReturnV03 struct {

	// Set of characteristics shared by all individual transactions included in the message.
	GroupHeader *iso20022.GroupHeader54 `xml:"GrpHdr"`

	// Information concerning the original group of transactions, to which the message refers.
	OriginalGroupInformation *iso20022.OriginalGroupHeader2 `xml:"OrgnlGrpInf,omitempty"`

	// Information concerning the original transactions, to which the return message refers.
	TransactionInformation []*iso20022.PaymentTransaction34 `xml:"TxInf,omitempty"`

	// Additional information that cannot be captured in the structured elements and/or any other specific block.
	SupplementaryData []*iso20022.SupplementaryData1 `xml:"SplmtryData,omitempty"`
}

Scope The PaymentReturn message is sent by an agent to the previous agent in the payment chain to undo a payment previously settled. Usage The PaymentReturn message is exchanged between agents to return funds after settlement of credit transfer instructions (i.e. FIToFICustomerCreditTransfer message and FinancialInstitutionCreditTransfer message) or direct debit instructions (FIToFICustomerDirectDebit message). The PaymentReturn message should not be used between agents and non-financial institution customers. Non-financial institution customers will be informed about a debit or a credit on their account(s) through a BankToCustomerDebitCreditNotification message ('notification') and/or BankToCustomerAccountReport/BankToCustomerStatement message ('statement'). The PaymentReturn message can be used to return single instructions or multiple instructions from one or different files. The PaymentReturn message can be used in domestic and cross-border scenarios. The PaymentReturn message refers to the original instruction(s) by means of references only or by means of references and a set of elements from the original instruction.

func (p *PaymentReturnV03) AddGroupHeader() *iso20022.GroupHeader54

func (p *PaymentReturnV03) AddOriginalGroupInformation() *iso20022.OriginalGroupHeader2

func (p *PaymentReturnV03) AddSupplementaryData() *iso20022.SupplementaryData1

func (p *PaymentReturnV03) AddTransactionInformation() *iso20022.PaymentTransaction34

type PaymentReturnV04 ¶

type PaymentReturnV04 struct {

	// Set of characteristics shared by all individual transactions included in the message.
	GroupHeader *iso20022.GroupHeader54 `xml:"GrpHdr"`

	// Information concerning the original group of transactions, to which the message refers.
	OriginalGroupInformation *iso20022.OriginalGroupHeader2 `xml:"OrgnlGrpInf,omitempty"`

	// Information concerning the original transactions, to which the return message refers.
	TransactionInformation []*iso20022.PaymentTransaction44 `xml:"TxInf,omitempty"`

	// Additional information that cannot be captured in the structured elements and/or any other specific block.
	SupplementaryData []*iso20022.SupplementaryData1 `xml:"SplmtryData,omitempty"`
}

Scope The PaymentReturn message is sent by an agent to the previous agent in the payment chain to undo a payment previously settled. Usage The PaymentReturn message is exchanged between agents to return funds after settlement of credit transfer instructions (i.e. FIToFICustomerCreditTransfer message and FinancialInstitutionCreditTransfer message) or direct debit instructions (FIToFICustomerDirectDebit message). The PaymentReturn message should not be used between agents and non-financial institution customers. Non-financial institution customers will be informed about a debit or a credit on their account(s) through a BankToCustomerDebitCreditNotification message ('notification') and/or BankToCustomerAccountReport/BankToCustomerStatement message ('statement'). The PaymentReturn message can be used to return single instructions or multiple instructions from one or different files. The PaymentReturn message can be used in domestic and cross-border scenarios. The PaymentReturn message refers to the original instruction(s) by means of references only or by means of references and a set of elements from the original instruction.

func (p *PaymentReturnV04) AddGroupHeader() *iso20022.GroupHeader54

func (p *PaymentReturnV04) AddOriginalGroupInformation() *iso20022.OriginalGroupHeader2

func (p *PaymentReturnV04) AddSupplementaryData() *iso20022.SupplementaryData1

func (p *PaymentReturnV04) AddTransactionInformation() *iso20022.PaymentTransaction44

type PaymentReturnV05 ¶

type PaymentReturnV05 struct {

	// Set of characteristics shared by all individual transactions included in the message.
	GroupHeader *iso20022.GroupHeader54 `xml:"GrpHdr"`

	// Information concerning the original group of transactions, to which the message refers.
	OriginalGroupInformation *iso20022.OriginalGroupHeader2 `xml:"OrgnlGrpInf,omitempty"`

	// Information concerning the original transactions, to which the return message refers.
	TransactionInformation []*iso20022.PaymentTransaction50 `xml:"TxInf,omitempty"`

	// Additional information that cannot be captured in the structured elements and/or any other specific block.
	SupplementaryData []*iso20022.SupplementaryData1 `xml:"SplmtryData,omitempty"`
}

Scope The PaymentReturn message is sent by an agent to the previous agent in the payment chain to undo a payment previously settled. Usage The PaymentReturn message is exchanged between agents to return funds after settlement of credit transfer instructions (i.e. FIToFICustomerCreditTransfer message and FinancialInstitutionCreditTransfer message) or direct debit instructions (FIToFICustomerDirectDebit message). The PaymentReturn message should not be used between agents and non-financial institution customers. Non-financial institution customers will be informed about a debit or a credit on their account(s) through a BankToCustomerDebitCreditNotification message ('notification') and/or BankToCustomerAccountReport/BankToCustomerStatement message ('statement'). The PaymentReturn message can be used to return single instructions or multiple instructions from one or different files. The PaymentReturn message can be used in domestic and cross-border scenarios. The PaymentReturn message refers to the original instruction(s) by means of references only or by means of references and a set of elements from the original instruction.

func (p *PaymentReturnV05) AddGroupHeader() *iso20022.GroupHeader54

func (p *PaymentReturnV05) AddOriginalGroupInformation() *iso20022.OriginalGroupHeader2

func (p *PaymentReturnV05) AddSupplementaryData() *iso20022.SupplementaryData1

func (p *PaymentReturnV05) AddTransactionInformation() *iso20022.PaymentTransaction50

type PaymentReturnV06 ¶

type PaymentReturnV06 struct {

	// Set of characteristics shared by all individual transactions included in the message.
	GroupHeader *iso20022.GroupHeader72 `xml:"GrpHdr"`

	// Information concerning the original group of transactions, to which the message refers.
	OriginalGroupInformation *iso20022.OriginalGroupHeader2 `xml:"OrgnlGrpInf,omitempty"`

	// Information concerning the original transactions, to which the return message refers.
	TransactionInformation []*iso20022.PaymentTransaction65 `xml:"TxInf,omitempty"`

	// Additional information that cannot be captured in the structured elements and/or any other specific block.
	SupplementaryData []*iso20022.SupplementaryData1 `xml:"SplmtryData,omitempty"`
}

Scope The PaymentReturn message is sent by an agent to the previous agent in the payment chain to undo a payment previously settled. Usage The PaymentReturn message is exchanged between agents to return funds after settlement of credit transfer instructions (i.e. FIToFICustomerCreditTransfer message and FinancialInstitutionCreditTransfer message) or direct debit instructions (FIToFICustomerDirectDebit message). The PaymentReturn message should not be used between agents and non-financial institution customers. Non-financial institution customers will be informed about a debit or a credit on their account(s) through a BankToCustomerDebitCreditNotification message ('notification') and/or BankToCustomerAccountReport/BankToCustomerStatement message ('statement'). The PaymentReturn message can be used to return single instructions or multiple instructions from one or different files. The PaymentReturn message can be used in domestic and cross-border scenarios. The PaymentReturn message refers to the original instruction(s) by means of references only or by means of references and a set of elements from the original instruction.

func (p *PaymentReturnV06) AddGroupHeader() *iso20022.GroupHeader72

func (p *PaymentReturnV06) AddOriginalGroupInformation() *iso20022.OriginalGroupHeader2

func (p *PaymentReturnV06) AddSupplementaryData() *iso20022.SupplementaryData1

func (p *PaymentReturnV06) AddTransactionInformation() *iso20022.PaymentTransaction65

type PaymentReturnV07 ¶

type PaymentReturnV07 struct {

	// Set of characteristics shared by all individual transactions included in the message.
	GroupHeader *iso20022.GroupHeader72 `xml:"GrpHdr"`

	// Information concerning the original group of transactions, to which the message refers.
	OriginalGroupInformation *iso20022.OriginalGroupHeader2 `xml:"OrgnlGrpInf,omitempty"`

	// Information concerning the original transactions, to which the return message refers.
	TransactionInformation []*iso20022.PaymentTransaction76 `xml:"TxInf,omitempty"`

	// Additional information that cannot be captured in the structured elements and/or any other specific block.
	SupplementaryData []*iso20022.SupplementaryData1 `xml:"SplmtryData,omitempty"`
}

Scope The PaymentReturn message is sent by an agent to the previous agent in the payment chain to undo a payment previously settled. Usage The PaymentReturn message is exchanged between agents to return funds after settlement of credit transfer instructions (i.e. FIToFICustomerCreditTransfer message and FinancialInstitutionCreditTransfer message) or direct debit instructions (FIToFICustomerDirectDebit message). The PaymentReturn message should not be used between agents and non-financial institution customers. Non-financial institution customers will be informed about a debit or a credit on their account(s) through a BankToCustomerDebitCreditNotification message ('notification') and/or BankToCustomerAccountReport/BankToCustomerStatement message ('statement'). The PaymentReturn message can be used to return single instructions or multiple instructions from one or different files. The PaymentReturn message can be used in domestic and cross-border scenarios. The PaymentReturn message refers to the original instruction(s) by means of references only or by means of references and a set of elements from the original instruction.

func (p *PaymentReturnV07) AddGroupHeader() *iso20022.GroupHeader72

func (p *PaymentReturnV07) AddOriginalGroupInformation() *iso20022.OriginalGroupHeader2

func (p *PaymentReturnV07) AddSupplementaryData() *iso20022.SupplementaryData1

func (p *PaymentReturnV07) AddTransactionInformation() *iso20022.PaymentTransaction76

type PaymentStatusReportV02 ¶

type PaymentStatusReportV02 struct {

	// Set of characteristics shared by all individual transactions included in the message.
	GroupHeader *iso20022.GroupHeader5 `xml:"GrpHdr"`

	// Original group information concerning the group of transactions, to which the message refers to.
	OriginalGroupInformationAndStatus *iso20022.OriginalGroupInformation1 `xml:"OrgnlGrpInfAndSts"`

	// Information concerning the original transactions, to which the status report message refers.
	TransactionInformationAndStatus []*iso20022.PaymentTransactionInformation1 `xml:"TxInfAndSts,omitempty"`
}

Scope The PaymentStatusReport message is sent by an instructed agent to the previous party in the payment chain. It is used to inform this party about the positive or negative status of an instruction (either single or file). It is also used to report on a pending instruction. Usage The PaymentStatusReport message is exchanged between agents to provide status information about instructions previously sent. Its usage will always be governed by a bilateral agreement between the agents. The PaymentStatusReport message can be used to provide information about the status (e.g. rejection, acceptance) of a credit transfer instruction, a direct debit instruction, as well as other intra-agent instructions (e.g. PaymentCancellationRequest). The PaymentStatusReport message refers to the original instruction(s) by means of references only or by means of references and a set of elements from the original instruction. The PaymentStatusReport message can be used in domestic and cross-border scenarios. The PaymentStatusReport message exchanged between agents is identified in the schema as follows: urn:iso:std:iso:20022:tech:xsd:pacs.002.001.02

func (p *PaymentStatusReportV02) AddGroupHeader() *iso20022.GroupHeader5

func (p *PaymentStatusReportV02) AddOriginalGroupInformationAndStatus() *iso20022.OriginalGroupInformation1

func (p *PaymentStatusReportV02) AddTransactionInformationAndStatus() *iso20022.PaymentTransactionInformation1