o_b_write_international_standing_order_consent6.go

// Code generated by go-swagger; DO NOT EDIT.

package models

// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command

import (
	"context"
	"encoding/json"

	"github.com/go-openapi/errors"
	"github.com/go-openapi/strfmt"
	"github.com/go-openapi/swag"
	"github.com/go-openapi/validate"
)

// OBWriteInternationalStandingOrderConsent6 o b write international standing order consent6
//
// swagger:model OBWriteInternationalStandingOrderConsent6
type OBWriteInternationalStandingOrderConsent6 struct {

	// data
	// Required: true
	Data *OBWriteInternationalStandingOrderConsent6Data `json:"Data"`

	// risk
	// Required: true
	Risk *OBRisk1 `json:"Risk"`
}

// Validate validates this o b write international standing order consent6
func (m *OBWriteInternationalStandingOrderConsent6) Validate(formats strfmt.Registry) error {
	var res []error

	if err := m.validateData(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateRisk(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6) validateData(formats strfmt.Registry) error {

	if err := validate.Required("Data", "body", m.Data); err != nil {
		return err
	}

	if m.Data != nil {
		if err := m.Data.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("Data")
			}
			return err
		}
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6) validateRisk(formats strfmt.Registry) error {

	if err := validate.Required("Risk", "body", m.Risk); err != nil {
		return err
	}

	if m.Risk != nil {
		if err := m.Risk.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("Risk")
			}
			return err
		}
	}

	return nil
}

// ContextValidate validate this o b write international standing order consent6 based on the context it is used
func (m *OBWriteInternationalStandingOrderConsent6) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

	if err := m.contextValidateData(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateRisk(ctx, formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6) contextValidateData(ctx context.Context, formats strfmt.Registry) error {

	if m.Data != nil {
		if err := m.Data.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("Data")
			}
			return err
		}
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6) contextValidateRisk(ctx context.Context, formats strfmt.Registry) error {

	if m.Risk != nil {
		if err := m.Risk.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("Risk")
			}
			return err
		}
	}

	return nil
}

// MarshalBinary interface implementation
func (m *OBWriteInternationalStandingOrderConsent6) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *OBWriteInternationalStandingOrderConsent6) UnmarshalBinary(b []byte) error {
	var res OBWriteInternationalStandingOrderConsent6
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// OBWriteInternationalStandingOrderConsent6Data o b write international standing order consent6 data
//
// swagger:model OBWriteInternationalStandingOrderConsent6Data
type OBWriteInternationalStandingOrderConsent6Data struct {

	// authorisation
	Authorisation *OBWriteInternationalStandingOrderConsent6DataAuthorisation `json:"Authorisation,omitempty"`

	// initiation
	// Required: true
	Initiation *OBWriteInternationalStandingOrderConsent6DataInitiation `json:"Initiation"`

	// Specifies the Open Banking service request types.
	// Required: true
	// Enum: [Create]
	Permission *string `json:"Permission"`

	// Specifies to share the refund account details with PISP
	// Enum: [No Yes]
	ReadRefundAccount string `json:"ReadRefundAccount,omitempty"`

	// s c a support data
	SCASupportData *OBWriteInternationalStandingOrderConsent6DataSCASupportData `json:"SCASupportData,omitempty"`
}

// Validate validates this o b write international standing order consent6 data
func (m *OBWriteInternationalStandingOrderConsent6Data) Validate(formats strfmt.Registry) error {
	var res []error

	if err := m.validateAuthorisation(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateInitiation(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validatePermission(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateReadRefundAccount(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateSCASupportData(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6Data) validateAuthorisation(formats strfmt.Registry) error {
	if swag.IsZero(m.Authorisation) { // not required
		return nil
	}

	if m.Authorisation != nil {
		if err := m.Authorisation.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("Data" + "." + "Authorisation")
			}
			return err
		}
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6Data) validateInitiation(formats strfmt.Registry) error {

	if err := validate.Required("Data"+"."+"Initiation", "body", m.Initiation); err != nil {
		return err
	}

	if m.Initiation != nil {
		if err := m.Initiation.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("Data" + "." + "Initiation")
			}
			return err
		}
	}

	return nil
}

var oBWriteInternationalStandingOrderConsent6DataTypePermissionPropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["Create"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		oBWriteInternationalStandingOrderConsent6DataTypePermissionPropEnum = append(oBWriteInternationalStandingOrderConsent6DataTypePermissionPropEnum, v)
	}
}

const (

	// OBWriteInternationalStandingOrderConsent6DataPermissionCreate captures enum value "Create"
	OBWriteInternationalStandingOrderConsent6DataPermissionCreate string = "Create"
)

// prop value enum
func (m *OBWriteInternationalStandingOrderConsent6Data) validatePermissionEnum(path, location string, value string) error {
	if err := validate.EnumCase(path, location, value, oBWriteInternationalStandingOrderConsent6DataTypePermissionPropEnum, true); err != nil {
		return err
	}
	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6Data) validatePermission(formats strfmt.Registry) error {

	if err := validate.Required("Data"+"."+"Permission", "body", m.Permission); err != nil {
		return err
	}

	// value enum
	if err := m.validatePermissionEnum("Data"+"."+"Permission", "body", *m.Permission); err != nil {
		return err
	}

	return nil
}

var oBWriteInternationalStandingOrderConsent6DataTypeReadRefundAccountPropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["No","Yes"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		oBWriteInternationalStandingOrderConsent6DataTypeReadRefundAccountPropEnum = append(oBWriteInternationalStandingOrderConsent6DataTypeReadRefundAccountPropEnum, v)
	}
}

const (

	// OBWriteInternationalStandingOrderConsent6DataReadRefundAccountNo captures enum value "No"
	OBWriteInternationalStandingOrderConsent6DataReadRefundAccountNo string = "No"

	// OBWriteInternationalStandingOrderConsent6DataReadRefundAccountYes captures enum value "Yes"
	OBWriteInternationalStandingOrderConsent6DataReadRefundAccountYes string = "Yes"
)

// prop value enum
func (m *OBWriteInternationalStandingOrderConsent6Data) validateReadRefundAccountEnum(path, location string, value string) error {
	if err := validate.EnumCase(path, location, value, oBWriteInternationalStandingOrderConsent6DataTypeReadRefundAccountPropEnum, true); err != nil {
		return err
	}
	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6Data) validateReadRefundAccount(formats strfmt.Registry) error {
	if swag.IsZero(m.ReadRefundAccount) { // not required
		return nil
	}

	// value enum
	if err := m.validateReadRefundAccountEnum("Data"+"."+"ReadRefundAccount", "body", m.ReadRefundAccount); err != nil {
		return err
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6Data) validateSCASupportData(formats strfmt.Registry) error {
	if swag.IsZero(m.SCASupportData) { // not required
		return nil
	}

	if m.SCASupportData != nil {
		if err := m.SCASupportData.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("Data" + "." + "SCASupportData")
			}
			return err
		}
	}

	return nil
}

// ContextValidate validate this o b write international standing order consent6 data based on the context it is used
func (m *OBWriteInternationalStandingOrderConsent6Data) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

	if err := m.contextValidateAuthorisation(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateInitiation(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateSCASupportData(ctx, formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6Data) contextValidateAuthorisation(ctx context.Context, formats strfmt.Registry) error {

	if m.Authorisation != nil {
		if err := m.Authorisation.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("Data" + "." + "Authorisation")
			}
			return err
		}
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6Data) contextValidateInitiation(ctx context.Context, formats strfmt.Registry) error {

	if m.Initiation != nil {
		if err := m.Initiation.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("Data" + "." + "Initiation")
			}
			return err
		}
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6Data) contextValidateSCASupportData(ctx context.Context, formats strfmt.Registry) error {

	if m.SCASupportData != nil {
		if err := m.SCASupportData.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("Data" + "." + "SCASupportData")
			}
			return err
		}
	}

	return nil
}

// MarshalBinary interface implementation
func (m *OBWriteInternationalStandingOrderConsent6Data) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *OBWriteInternationalStandingOrderConsent6Data) UnmarshalBinary(b []byte) error {
	var res OBWriteInternationalStandingOrderConsent6Data
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// OBWriteInternationalStandingOrderConsent6DataAuthorisation The authorisation type request from the TPP.
//
// swagger:model OBWriteInternationalStandingOrderConsent6DataAuthorisation
type OBWriteInternationalStandingOrderConsent6DataAuthorisation struct {

	// Type of authorisation flow requested.
	// Required: true
	// Enum: [Any Single]
	AuthorisationType *string `json:"AuthorisationType"`

	// Date and time at which the requested authorisation flow must be completed.All dates in the JSON payloads are represented in ISO 8601 date-time format.
	// All date-time fields in responses must include the timezone. An example is below:
	// 2017-04-05T10:43:07+00:00
	// Format: date-time
	CompletionDateTime strfmt.DateTime `json:"CompletionDateTime,omitempty"`
}

// Validate validates this o b write international standing order consent6 data authorisation
func (m *OBWriteInternationalStandingOrderConsent6DataAuthorisation) Validate(formats strfmt.Registry) error {
	var res []error

	if err := m.validateAuthorisationType(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateCompletionDateTime(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

var oBWriteInternationalStandingOrderConsent6DataAuthorisationTypeAuthorisationTypePropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["Any","Single"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		oBWriteInternationalStandingOrderConsent6DataAuthorisationTypeAuthorisationTypePropEnum = append(oBWriteInternationalStandingOrderConsent6DataAuthorisationTypeAuthorisationTypePropEnum, v)
	}
}

const (

	// OBWriteInternationalStandingOrderConsent6DataAuthorisationAuthorisationTypeAny captures enum value "Any"
	OBWriteInternationalStandingOrderConsent6DataAuthorisationAuthorisationTypeAny string = "Any"

	// OBWriteInternationalStandingOrderConsent6DataAuthorisationAuthorisationTypeSingle captures enum value "Single"
	OBWriteInternationalStandingOrderConsent6DataAuthorisationAuthorisationTypeSingle string = "Single"
)

// prop value enum
func (m *OBWriteInternationalStandingOrderConsent6DataAuthorisation) validateAuthorisationTypeEnum(path, location string, value string) error {
	if err := validate.EnumCase(path, location, value, oBWriteInternationalStandingOrderConsent6DataAuthorisationTypeAuthorisationTypePropEnum, true); err != nil {
		return err
	}
	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataAuthorisation) validateAuthorisationType(formats strfmt.Registry) error {

	if err := validate.Required("Data"+"."+"Authorisation"+"."+"AuthorisationType", "body", m.AuthorisationType); err != nil {
		return err
	}

	// value enum
	if err := m.validateAuthorisationTypeEnum("Data"+"."+"Authorisation"+"."+"AuthorisationType", "body", *m.AuthorisationType); err != nil {
		return err
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataAuthorisation) validateCompletionDateTime(formats strfmt.Registry) error {
	if swag.IsZero(m.CompletionDateTime) { // not required
		return nil
	}

	if err := validate.FormatOf("Data"+"."+"Authorisation"+"."+"CompletionDateTime", "body", "date-time", m.CompletionDateTime.String(), formats); err != nil {
		return err
	}

	return nil
}

// ContextValidate validates this o b write international standing order consent6 data authorisation based on context it is used
func (m *OBWriteInternationalStandingOrderConsent6DataAuthorisation) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (m *OBWriteInternationalStandingOrderConsent6DataAuthorisation) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *OBWriteInternationalStandingOrderConsent6DataAuthorisation) UnmarshalBinary(b []byte) error {
	var res OBWriteInternationalStandingOrderConsent6DataAuthorisation
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// OBWriteInternationalStandingOrderConsent6DataInitiation The Initiation payload is sent by the initiating party to the ASPSP. It is used to request movement of funds from the debtor account to a creditor for an international standing order.
//
// swagger:model OBWriteInternationalStandingOrderConsent6DataInitiation
type OBWriteInternationalStandingOrderConsent6DataInitiation struct {

	// charge bearer
	ChargeBearer OBChargeBearerType1Code `json:"ChargeBearer,omitempty"`

	// creditor
	Creditor *OBWriteInternationalStandingOrderConsent6DataInitiationCreditor `json:"Creditor,omitempty"`

	// creditor account
	// Required: true
	CreditorAccount *OBWriteInternationalStandingOrderConsent6DataInitiationCreditorAccount `json:"CreditorAccount"`

	// creditor agent
	CreditorAgent *OBWriteInternationalStandingOrderConsent6DataInitiationCreditorAgent `json:"CreditorAgent,omitempty"`

	// Specifies the currency of the to be transferred amount, which is different from the currency of the debtor's account.
	// Required: true
	// Pattern: ^[A-Z]{3,3}$
	CurrencyOfTransfer *string `json:"CurrencyOfTransfer"`

	// debtor account
	DebtorAccount *OBWriteInternationalStandingOrderConsent6DataInitiationDebtorAccount `json:"DebtorAccount,omitempty"`

	// Country in which Credit Account is domiciled. Code to identify a country, a dependency, or another area of particular geopolitical interest, on the basis of country names obtained from the United Nations (ISO 3166, Alpha-2 code).
	// Pattern: [A-Z]{2,2}
	DestinationCountryCode string `json:"DestinationCountryCode,omitempty"`

	// Specifies the purpose of an international payment, when there is no corresponding 4 character code available in the ISO20022 list of Purpose Codes.
	// Max Length: 140
	// Min Length: 1
	ExtendedPurpose string `json:"ExtendedPurpose,omitempty"`

	// The date on which the final payment for a Standing Order schedule will be made.All dates in the JSON payloads are represented in ISO 8601 date-time format.
	// All date-time fields in responses must include the timezone. An example is below:
	// 2017-04-05T10:43:07+00:00
	// Format: date-time
	FinalPaymentDateTime strfmt.DateTime `json:"FinalPaymentDateTime,omitempty"`

	// The date on which the first payment for a Standing Order schedule will be made.All dates in the JSON payloads are represented in ISO 8601 date-time format.
	// All date-time fields in responses must include the timezone. An example is below:
	// 2017-04-05T10:43:07+00:00
	// Required: true
	// Format: date-time
	FirstPaymentDateTime *strfmt.DateTime `json:"FirstPaymentDateTime"`

	// Individual Definitions:
	// EvryDay - Every day
	// EvryWorkgDay - Every working day
	// IntrvlWkDay - An interval specified in weeks (01 to 09), and the day within the week (01 to 07)
	// WkInMnthDay - A monthly interval, specifying the week of the month (01 to 05) and day within the week (01 to 07)
	// IntrvlMnthDay - An interval specified in months (between 01 to 06, 12, 24), specifying the day within the month (-5 to -1, 1 to 31)
	// QtrDay - Quarterly (either ENGLISH, SCOTTISH, or RECEIVED).
	// ENGLISH = Paid on the 25th March, 24th June, 29th September and 25th December.
	// SCOTTISH = Paid on the 2nd February, 15th May, 1st August and 11th November.
	// RECEIVED = Paid on the 20th March, 19th June, 24th September and 20th December.
	// Individual Patterns:
	// EvryDay (ScheduleCode)
	// EvryWorkgDay (ScheduleCode)
	// IntrvlWkDay:IntervalInWeeks:DayInWeek (ScheduleCode + IntervalInWeeks + DayInWeek)
	// WkInMnthDay:WeekInMonth:DayInWeek (ScheduleCode + WeekInMonth + DayInWeek)
	// IntrvlMnthDay:IntervalInMonths:DayInMonth (ScheduleCode + IntervalInMonths + DayInMonth)
	// QtrDay: + either (ENGLISH, SCOTTISH or RECEIVED) ScheduleCode + QuarterDay
	// The regular expression for this element combines five smaller versions for each permitted pattern. To aid legibility - the components are presented individually here:
	// EvryDay
	// EvryWorkgDay
	// IntrvlWkDay:0[1-9]:0[1-7]
	// WkInMnthDay:0[1-5]:0[1-7]
	// IntrvlMnthDay:(0[1-6]|12|24):(-0[1-5]|0[1-9]|[12][0-9]|3[01])
	// QtrDay:(ENGLISH|SCOTTISH|RECEIVED)
	// Full Regular Expression:
	// ^(EvryDay)$|^(EvryWorkgDay)$|^(IntrvlWkDay:0[1-9]:0[1-7])$|^(WkInMnthDay:0[1-5]:0[1-7])$|^(IntrvlMnthDay:(0[1-6]|12|24):(-0[1-5]|0[1-9]|[12][0-9]|3[01]))$|^(QtrDay:(ENGLISH|SCOTTISH|RECEIVED))$
	// Required: true
	// Pattern: ^(EvryDay)$|^(EvryWorkgDay)$|^(IntrvlDay:((0[2-9])|([1-2][0-9])|3[0-1]))$|^(IntrvlWkDay:0[1-9]:0[1-7])$|^(WkInMnthDay:0[1-5]:0[1-7])$|^(IntrvlMnthDay:(0[1-6]|12|24):(-0[1-5]|0[1-9]|[12][0-9]|3[01]))$|^(QtrDay:(ENGLISH|SCOTTISH|RECEIVED))$
	Frequency *string `json:"Frequency"`

	// instructed amount
	// Required: true
	InstructedAmount *OBWriteInternationalStandingOrderConsent6DataInitiationInstructedAmount `json:"InstructedAmount"`

	// Number of the payments that will be made in completing this frequency sequence including any executed since the sequence start date.
	// Max Length: 35
	// Min Length: 1
	NumberOfPayments string `json:"NumberOfPayments,omitempty"`

	// Specifies the external purpose code in the format of character string with a maximum length of 4 characters.
	// The list of valid codes is an external code list published separately.
	// External code sets can be downloaded from www.iso20022.org.
	// Max Length: 4
	// Min Length: 1
	Purpose string `json:"Purpose,omitempty"`

	// Unique reference, as assigned by the creditor, to unambiguously refer to the payment transaction.
	// Usage: If available, the initiating party should provide this reference in the structured remittance information, to enable reconciliation by the creditor upon receipt of the amount of money.
	// If the business context requires the use of a creditor reference or a payment remit identification, and only one identifier can be passed through the end-to-end chain, the creditor's reference or payment remittance identification should be quoted in the end-to-end transaction identification.
	// Max Length: 35
	// Min Length: 1
	Reference string `json:"Reference,omitempty"`

	// supplementary data
	SupplementaryData OBSupplementaryData1 `json:"SupplementaryData,omitempty"`
}

// Validate validates this o b write international standing order consent6 data initiation
func (m *OBWriteInternationalStandingOrderConsent6DataInitiation) Validate(formats strfmt.Registry) error {
	var res []error

	if err := m.validateChargeBearer(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateCreditor(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateCreditorAccount(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateCreditorAgent(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateCurrencyOfTransfer(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateDebtorAccount(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateDestinationCountryCode(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateExtendedPurpose(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateFinalPaymentDateTime(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateFirstPaymentDateTime(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateFrequency(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateInstructedAmount(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateNumberOfPayments(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validatePurpose(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateReference(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiation) validateChargeBearer(formats strfmt.Registry) error {
	if swag.IsZero(m.ChargeBearer) { // not required
		return nil
	}

	if err := m.ChargeBearer.Validate(formats); err != nil {
		if ve, ok := err.(*errors.Validation); ok {
			return ve.ValidateName("Data" + "." + "Initiation" + "." + "ChargeBearer")
		}
		return err
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiation) validateCreditor(formats strfmt.Registry) error {
	if swag.IsZero(m.Creditor) { // not required
		return nil
	}

	if m.Creditor != nil {
		if err := m.Creditor.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("Data" + "." + "Initiation" + "." + "Creditor")
			}
			return err
		}
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiation) validateCreditorAccount(formats strfmt.Registry) error {

	if err := validate.Required("Data"+"."+"Initiation"+"."+"CreditorAccount", "body", m.CreditorAccount); err != nil {
		return err
	}

	if m.CreditorAccount != nil {
		if err := m.CreditorAccount.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("Data" + "." + "Initiation" + "." + "CreditorAccount")
			}
			return err
		}
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiation) validateCreditorAgent(formats strfmt.Registry) error {
	if swag.IsZero(m.CreditorAgent) { // not required
		return nil
	}

	if m.CreditorAgent != nil {
		if err := m.CreditorAgent.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("Data" + "." + "Initiation" + "." + "CreditorAgent")
			}
			return err
		}
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiation) validateCurrencyOfTransfer(formats strfmt.Registry) error {

	if err := validate.Required("Data"+"."+"Initiation"+"."+"CurrencyOfTransfer", "body", m.CurrencyOfTransfer); err != nil {
		return err
	}

	if err := validate.Pattern("Data"+"."+"Initiation"+"."+"CurrencyOfTransfer", "body", *m.CurrencyOfTransfer, `^[A-Z]{3,3}$`); err != nil {
		return err
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiation) validateDebtorAccount(formats strfmt.Registry) error {
	if swag.IsZero(m.DebtorAccount) { // not required
		return nil
	}

	if m.DebtorAccount != nil {
		if err := m.DebtorAccount.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("Data" + "." + "Initiation" + "." + "DebtorAccount")
			}
			return err
		}
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiation) validateDestinationCountryCode(formats strfmt.Registry) error {
	if swag.IsZero(m.DestinationCountryCode) { // not required
		return nil
	}

	if err := validate.Pattern("Data"+"."+"Initiation"+"."+"DestinationCountryCode", "body", m.DestinationCountryCode, `[A-Z]{2,2}`); err != nil {
		return err
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiation) validateExtendedPurpose(formats strfmt.Registry) error {
	if swag.IsZero(m.ExtendedPurpose) { // not required
		return nil
	}

	if err := validate.MinLength("Data"+"."+"Initiation"+"."+"ExtendedPurpose", "body", m.ExtendedPurpose, 1); err != nil {
		return err
	}

	if err := validate.MaxLength("Data"+"."+"Initiation"+"."+"ExtendedPurpose", "body", m.ExtendedPurpose, 140); err != nil {
		return err
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiation) validateFinalPaymentDateTime(formats strfmt.Registry) error {
	if swag.IsZero(m.FinalPaymentDateTime) { // not required
		return nil
	}

	if err := validate.FormatOf("Data"+"."+"Initiation"+"."+"FinalPaymentDateTime", "body", "date-time", m.FinalPaymentDateTime.String(), formats); err != nil {
		return err
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiation) validateFirstPaymentDateTime(formats strfmt.Registry) error {

	if err := validate.Required("Data"+"."+"Initiation"+"."+"FirstPaymentDateTime", "body", m.FirstPaymentDateTime); err != nil {
		return err
	}

	if err := validate.FormatOf("Data"+"."+"Initiation"+"."+"FirstPaymentDateTime", "body", "date-time", m.FirstPaymentDateTime.String(), formats); err != nil {
		return err
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiation) validateFrequency(formats strfmt.Registry) error {

	if err := validate.Required("Data"+"."+"Initiation"+"."+"Frequency", "body", m.Frequency); err != nil {
		return err
	}

	if err := validate.Pattern("Data"+"."+"Initiation"+"."+"Frequency", "body", *m.Frequency, `^(EvryDay)$|^(EvryWorkgDay)$|^(IntrvlDay:((0[2-9])|([1-2][0-9])|3[0-1]))$|^(IntrvlWkDay:0[1-9]:0[1-7])$|^(WkInMnthDay:0[1-5]:0[1-7])$|^(IntrvlMnthDay:(0[1-6]|12|24):(-0[1-5]|0[1-9]|[12][0-9]|3[01]))$|^(QtrDay:(ENGLISH|SCOTTISH|RECEIVED))$`); err != nil {
		return err
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiation) validateInstructedAmount(formats strfmt.Registry) error {

	if err := validate.Required("Data"+"."+"Initiation"+"."+"InstructedAmount", "body", m.InstructedAmount); err != nil {
		return err
	}

	if m.InstructedAmount != nil {
		if err := m.InstructedAmount.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("Data" + "." + "Initiation" + "." + "InstructedAmount")
			}
			return err
		}
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiation) validateNumberOfPayments(formats strfmt.Registry) error {
	if swag.IsZero(m.NumberOfPayments) { // not required
		return nil
	}

	if err := validate.MinLength("Data"+"."+"Initiation"+"."+"NumberOfPayments", "body", m.NumberOfPayments, 1); err != nil {
		return err
	}

	if err := validate.MaxLength("Data"+"."+"Initiation"+"."+"NumberOfPayments", "body", m.NumberOfPayments, 35); err != nil {
		return err
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiation) validatePurpose(formats strfmt.Registry) error {
	if swag.IsZero(m.Purpose) { // not required
		return nil
	}

	if err := validate.MinLength("Data"+"."+"Initiation"+"."+"Purpose", "body", m.Purpose, 1); err != nil {
		return err
	}

	if err := validate.MaxLength("Data"+"."+"Initiation"+"."+"Purpose", "body", m.Purpose, 4); err != nil {
		return err
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiation) validateReference(formats strfmt.Registry) error {
	if swag.IsZero(m.Reference) { // not required
		return nil
	}

	if err := validate.MinLength("Data"+"."+"Initiation"+"."+"Reference", "body", m.Reference, 1); err != nil {
		return err
	}

	if err := validate.MaxLength("Data"+"."+"Initiation"+"."+"Reference", "body", m.Reference, 35); err != nil {
		return err
	}

	return nil
}

// ContextValidate validate this o b write international standing order consent6 data initiation based on the context it is used
func (m *OBWriteInternationalStandingOrderConsent6DataInitiation) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

	if err := m.contextValidateChargeBearer(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateCreditor(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateCreditorAccount(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateCreditorAgent(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateDebtorAccount(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateInstructedAmount(ctx, formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiation) contextValidateChargeBearer(ctx context.Context, formats strfmt.Registry) error {

	if err := m.ChargeBearer.ContextValidate(ctx, formats); err != nil {
		if ve, ok := err.(*errors.Validation); ok {
			return ve.ValidateName("Data" + "." + "Initiation" + "." + "ChargeBearer")
		}
		return err
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiation) contextValidateCreditor(ctx context.Context, formats strfmt.Registry) error {

	if m.Creditor != nil {
		if err := m.Creditor.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("Data" + "." + "Initiation" + "." + "Creditor")
			}
			return err
		}
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiation) contextValidateCreditorAccount(ctx context.Context, formats strfmt.Registry) error {

	if m.CreditorAccount != nil {
		if err := m.CreditorAccount.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("Data" + "." + "Initiation" + "." + "CreditorAccount")
			}
			return err
		}
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiation) contextValidateCreditorAgent(ctx context.Context, formats strfmt.Registry) error {

	if m.CreditorAgent != nil {
		if err := m.CreditorAgent.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("Data" + "." + "Initiation" + "." + "CreditorAgent")
			}
			return err
		}
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiation) contextValidateDebtorAccount(ctx context.Context, formats strfmt.Registry) error {

	if m.DebtorAccount != nil {
		if err := m.DebtorAccount.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("Data" + "." + "Initiation" + "." + "DebtorAccount")
			}
			return err
		}
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiation) contextValidateInstructedAmount(ctx context.Context, formats strfmt.Registry) error {

	if m.InstructedAmount != nil {
		if err := m.InstructedAmount.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("Data" + "." + "Initiation" + "." + "InstructedAmount")
			}
			return err
		}
	}

	return nil
}

// MarshalBinary interface implementation
func (m *OBWriteInternationalStandingOrderConsent6DataInitiation) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *OBWriteInternationalStandingOrderConsent6DataInitiation) UnmarshalBinary(b []byte) error {
	var res OBWriteInternationalStandingOrderConsent6DataInitiation
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// OBWriteInternationalStandingOrderConsent6DataInitiationCreditor Party to which an amount of money is due.
//
// swagger:model OBWriteInternationalStandingOrderConsent6DataInitiationCreditor
type OBWriteInternationalStandingOrderConsent6DataInitiationCreditor struct {

	// Name by which a party is known and which is usually used to identify that party.
	// Max Length: 350
	// Min Length: 1
	Name string `json:"Name,omitempty"`

	// postal address
	PostalAddress *OBPostalAddress6 `json:"PostalAddress,omitempty"`
}

// Validate validates this o b write international standing order consent6 data initiation creditor
func (m *OBWriteInternationalStandingOrderConsent6DataInitiationCreditor) Validate(formats strfmt.Registry) error {
	var res []error

	if err := m.validateName(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validatePostalAddress(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiationCreditor) validateName(formats strfmt.Registry) error {
	if swag.IsZero(m.Name) { // not required
		return nil
	}

	if err := validate.MinLength("Data"+"."+"Initiation"+"."+"Creditor"+"."+"Name", "body", m.Name, 1); err != nil {
		return err
	}

	if err := validate.MaxLength("Data"+"."+"Initiation"+"."+"Creditor"+"."+"Name", "body", m.Name, 350); err != nil {
		return err
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiationCreditor) validatePostalAddress(formats strfmt.Registry) error {
	if swag.IsZero(m.PostalAddress) { // not required
		return nil
	}

	if m.PostalAddress != nil {
		if err := m.PostalAddress.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("Data" + "." + "Initiation" + "." + "Creditor" + "." + "PostalAddress")
			}
			return err
		}
	}

	return nil
}

// ContextValidate validate this o b write international standing order consent6 data initiation creditor based on the context it is used
func (m *OBWriteInternationalStandingOrderConsent6DataInitiationCreditor) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

	if err := m.contextValidatePostalAddress(ctx, formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiationCreditor) contextValidatePostalAddress(ctx context.Context, formats strfmt.Registry) error {

	if m.PostalAddress != nil {
		if err := m.PostalAddress.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("Data" + "." + "Initiation" + "." + "Creditor" + "." + "PostalAddress")
			}
			return err
		}
	}

	return nil
}

// MarshalBinary interface implementation
func (m *OBWriteInternationalStandingOrderConsent6DataInitiationCreditor) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *OBWriteInternationalStandingOrderConsent6DataInitiationCreditor) UnmarshalBinary(b []byte) error {
	var res OBWriteInternationalStandingOrderConsent6DataInitiationCreditor
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// OBWriteInternationalStandingOrderConsent6DataInitiationCreditorAccount Provides the details to identify the beneficiary account.
//
// swagger:model OBWriteInternationalStandingOrderConsent6DataInitiationCreditorAccount
type OBWriteInternationalStandingOrderConsent6DataInitiationCreditorAccount struct {

	// identification
	// Required: true
	Identification *Identification0 `json:"Identification"`

	// The account name is the name or names of the account owner(s) represented at an account level.
	// Note, the account name is not the product name or the nickname of the account.
	// OB: ASPSPs may carry out name validation for Confirmation of Payee, but it is not mandatory.
	// Required: true
	// Max Length: 350
	// Min Length: 1
	Name *string `json:"Name"`

	// scheme name
	// Required: true
	SchemeName *OBExternalAccountIdentification4Code `json:"SchemeName"`

	// secondary identification
	SecondaryIdentification SecondaryIdentification `json:"SecondaryIdentification,omitempty"`
}

// Validate validates this o b write international standing order consent6 data initiation creditor account
func (m *OBWriteInternationalStandingOrderConsent6DataInitiationCreditorAccount) Validate(formats strfmt.Registry) error {
	var res []error

	if err := m.validateIdentification(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateName(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateSchemeName(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateSecondaryIdentification(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiationCreditorAccount) validateIdentification(formats strfmt.Registry) error {

	if err := validate.Required("Data"+"."+"Initiation"+"."+"CreditorAccount"+"."+"Identification", "body", m.Identification); err != nil {
		return err
	}

	if err := validate.Required("Data"+"."+"Initiation"+"."+"CreditorAccount"+"."+"Identification", "body", m.Identification); err != nil {
		return err
	}

	if m.Identification != nil {
		if err := m.Identification.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("Data" + "." + "Initiation" + "." + "CreditorAccount" + "." + "Identification")
			}
			return err
		}
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiationCreditorAccount) validateName(formats strfmt.Registry) error {

	if err := validate.Required("Data"+"."+"Initiation"+"."+"CreditorAccount"+"."+"Name", "body", m.Name); err != nil {
		return err
	}

	if err := validate.MinLength("Data"+"."+"Initiation"+"."+"CreditorAccount"+"."+"Name", "body", *m.Name, 1); err != nil {
		return err
	}

	if err := validate.MaxLength("Data"+"."+"Initiation"+"."+"CreditorAccount"+"."+"Name", "body", *m.Name, 350); err != nil {
		return err
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiationCreditorAccount) validateSchemeName(formats strfmt.Registry) error {

	if err := validate.Required("Data"+"."+"Initiation"+"."+"CreditorAccount"+"."+"SchemeName", "body", m.SchemeName); err != nil {
		return err
	}

	if err := validate.Required("Data"+"."+"Initiation"+"."+"CreditorAccount"+"."+"SchemeName", "body", m.SchemeName); err != nil {
		return err
	}

	if m.SchemeName != nil {
		if err := m.SchemeName.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("Data" + "." + "Initiation" + "." + "CreditorAccount" + "." + "SchemeName")
			}
			return err
		}
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiationCreditorAccount) validateSecondaryIdentification(formats strfmt.Registry) error {
	if swag.IsZero(m.SecondaryIdentification) { // not required
		return nil
	}

	if err := m.SecondaryIdentification.Validate(formats); err != nil {
		if ve, ok := err.(*errors.Validation); ok {
			return ve.ValidateName("Data" + "." + "Initiation" + "." + "CreditorAccount" + "." + "SecondaryIdentification")
		}
		return err
	}

	return nil
}

// ContextValidate validate this o b write international standing order consent6 data initiation creditor account based on the context it is used
func (m *OBWriteInternationalStandingOrderConsent6DataInitiationCreditorAccount) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

	if err := m.contextValidateIdentification(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateSchemeName(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateSecondaryIdentification(ctx, formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiationCreditorAccount) contextValidateIdentification(ctx context.Context, formats strfmt.Registry) error {

	if m.Identification != nil {
		if err := m.Identification.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("Data" + "." + "Initiation" + "." + "CreditorAccount" + "." + "Identification")
			}
			return err
		}
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiationCreditorAccount) contextValidateSchemeName(ctx context.Context, formats strfmt.Registry) error {

	if m.SchemeName != nil {
		if err := m.SchemeName.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("Data" + "." + "Initiation" + "." + "CreditorAccount" + "." + "SchemeName")
			}
			return err
		}
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiationCreditorAccount) contextValidateSecondaryIdentification(ctx context.Context, formats strfmt.Registry) error {

	if err := m.SecondaryIdentification.ContextValidate(ctx, formats); err != nil {
		if ve, ok := err.(*errors.Validation); ok {
			return ve.ValidateName("Data" + "." + "Initiation" + "." + "CreditorAccount" + "." + "SecondaryIdentification")
		}
		return err
	}

	return nil
}

// MarshalBinary interface implementation
func (m *OBWriteInternationalStandingOrderConsent6DataInitiationCreditorAccount) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *OBWriteInternationalStandingOrderConsent6DataInitiationCreditorAccount) UnmarshalBinary(b []byte) error {
	var res OBWriteInternationalStandingOrderConsent6DataInitiationCreditorAccount
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// OBWriteInternationalStandingOrderConsent6DataInitiationCreditorAgent Party that manages the account on behalf of the account owner, that is manages the registration and booking of entries on the account, calculates balances on the account and provides information about the account.
// This is the servicer of the beneficiary account.
//
// swagger:model OBWriteInternationalStandingOrderConsent6DataInitiationCreditorAgent
type OBWriteInternationalStandingOrderConsent6DataInitiationCreditorAgent struct {

	// Unique and unambiguous identification of the servicing institution.
	// Max Length: 35
	// Min Length: 1
	Identification string `json:"Identification,omitempty"`

	// name
	Name Name `json:"Name,omitempty"`

	// postal address
	PostalAddress *OBPostalAddress6 `json:"PostalAddress,omitempty"`

	// scheme name
	SchemeName OBExternalFinancialInstitutionIdentification4Code `json:"SchemeName,omitempty"`
}

// Validate validates this o b write international standing order consent6 data initiation creditor agent
func (m *OBWriteInternationalStandingOrderConsent6DataInitiationCreditorAgent) Validate(formats strfmt.Registry) error {
	var res []error

	if err := m.validateIdentification(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateName(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validatePostalAddress(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateSchemeName(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiationCreditorAgent) validateIdentification(formats strfmt.Registry) error {
	if swag.IsZero(m.Identification) { // not required
		return nil
	}

	if err := validate.MinLength("Data"+"."+"Initiation"+"."+"CreditorAgent"+"."+"Identification", "body", m.Identification, 1); err != nil {
		return err
	}

	if err := validate.MaxLength("Data"+"."+"Initiation"+"."+"CreditorAgent"+"."+"Identification", "body", m.Identification, 35); err != nil {
		return err
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiationCreditorAgent) validateName(formats strfmt.Registry) error {
	if swag.IsZero(m.Name) { // not required
		return nil
	}

	if err := m.Name.Validate(formats); err != nil {
		if ve, ok := err.(*errors.Validation); ok {
			return ve.ValidateName("Data" + "." + "Initiation" + "." + "CreditorAgent" + "." + "Name")
		}
		return err
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiationCreditorAgent) validatePostalAddress(formats strfmt.Registry) error {
	if swag.IsZero(m.PostalAddress) { // not required
		return nil
	}

	if m.PostalAddress != nil {
		if err := m.PostalAddress.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("Data" + "." + "Initiation" + "." + "CreditorAgent" + "." + "PostalAddress")
			}
			return err
		}
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiationCreditorAgent) validateSchemeName(formats strfmt.Registry) error {
	if swag.IsZero(m.SchemeName) { // not required
		return nil
	}

	if err := m.SchemeName.Validate(formats); err != nil {
		if ve, ok := err.(*errors.Validation); ok {
			return ve.ValidateName("Data" + "." + "Initiation" + "." + "CreditorAgent" + "." + "SchemeName")
		}
		return err
	}

	return nil
}

// ContextValidate validate this o b write international standing order consent6 data initiation creditor agent based on the context it is used
func (m *OBWriteInternationalStandingOrderConsent6DataInitiationCreditorAgent) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

	if err := m.contextValidateName(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidatePostalAddress(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateSchemeName(ctx, formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiationCreditorAgent) contextValidateName(ctx context.Context, formats strfmt.Registry) error {

	if err := m.Name.ContextValidate(ctx, formats); err != nil {
		if ve, ok := err.(*errors.Validation); ok {
			return ve.ValidateName("Data" + "." + "Initiation" + "." + "CreditorAgent" + "." + "Name")
		}
		return err
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiationCreditorAgent) contextValidatePostalAddress(ctx context.Context, formats strfmt.Registry) error {

	if m.PostalAddress != nil {
		if err := m.PostalAddress.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("Data" + "." + "Initiation" + "." + "CreditorAgent" + "." + "PostalAddress")
			}
			return err
		}
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiationCreditorAgent) contextValidateSchemeName(ctx context.Context, formats strfmt.Registry) error {

	if err := m.SchemeName.ContextValidate(ctx, formats); err != nil {
		if ve, ok := err.(*errors.Validation); ok {
			return ve.ValidateName("Data" + "." + "Initiation" + "." + "CreditorAgent" + "." + "SchemeName")
		}
		return err
	}

	return nil
}

// MarshalBinary interface implementation
func (m *OBWriteInternationalStandingOrderConsent6DataInitiationCreditorAgent) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *OBWriteInternationalStandingOrderConsent6DataInitiationCreditorAgent) UnmarshalBinary(b []byte) error {
	var res OBWriteInternationalStandingOrderConsent6DataInitiationCreditorAgent
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// OBWriteInternationalStandingOrderConsent6DataInitiationDebtorAccount Provides the details to identify the debtor account.
//
// swagger:model OBWriteInternationalStandingOrderConsent6DataInitiationDebtorAccount
type OBWriteInternationalStandingOrderConsent6DataInitiationDebtorAccount struct {

	// identification
	// Required: true
	Identification *Identification0 `json:"Identification"`

	// The account name is the name or names of the account owner(s) represented at an account level, as displayed by the ASPSP's online channels.
	// Note, the account name is not the product name or the nickname of the account.
	// Max Length: 350
	// Min Length: 1
	Name string `json:"Name,omitempty"`

	// scheme name
	// Required: true
	SchemeName *OBExternalAccountIdentification4Code `json:"SchemeName"`

	// secondary identification
	SecondaryIdentification SecondaryIdentification `json:"SecondaryIdentification,omitempty"`
}

// Validate validates this o b write international standing order consent6 data initiation debtor account
func (m *OBWriteInternationalStandingOrderConsent6DataInitiationDebtorAccount) Validate(formats strfmt.Registry) error {
	var res []error

	if err := m.validateIdentification(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateName(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateSchemeName(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateSecondaryIdentification(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiationDebtorAccount) validateIdentification(formats strfmt.Registry) error {

	if err := validate.Required("Data"+"."+"Initiation"+"."+"DebtorAccount"+"."+"Identification", "body", m.Identification); err != nil {
		return err
	}

	if err := validate.Required("Data"+"."+"Initiation"+"."+"DebtorAccount"+"."+"Identification", "body", m.Identification); err != nil {
		return err
	}

	if m.Identification != nil {
		if err := m.Identification.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("Data" + "." + "Initiation" + "." + "DebtorAccount" + "." + "Identification")
			}
			return err
		}
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiationDebtorAccount) validateName(formats strfmt.Registry) error {
	if swag.IsZero(m.Name) { // not required
		return nil
	}

	if err := validate.MinLength("Data"+"."+"Initiation"+"."+"DebtorAccount"+"."+"Name", "body", m.Name, 1); err != nil {
		return err
	}

	if err := validate.MaxLength("Data"+"."+"Initiation"+"."+"DebtorAccount"+"."+"Name", "body", m.Name, 350); err != nil {
		return err
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiationDebtorAccount) validateSchemeName(formats strfmt.Registry) error {

	if err := validate.Required("Data"+"."+"Initiation"+"."+"DebtorAccount"+"."+"SchemeName", "body", m.SchemeName); err != nil {
		return err
	}

	if err := validate.Required("Data"+"."+"Initiation"+"."+"DebtorAccount"+"."+"SchemeName", "body", m.SchemeName); err != nil {
		return err
	}

	if m.SchemeName != nil {
		if err := m.SchemeName.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("Data" + "." + "Initiation" + "." + "DebtorAccount" + "." + "SchemeName")
			}
			return err
		}
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiationDebtorAccount) validateSecondaryIdentification(formats strfmt.Registry) error {
	if swag.IsZero(m.SecondaryIdentification) { // not required
		return nil
	}

	if err := m.SecondaryIdentification.Validate(formats); err != nil {
		if ve, ok := err.(*errors.Validation); ok {
			return ve.ValidateName("Data" + "." + "Initiation" + "." + "DebtorAccount" + "." + "SecondaryIdentification")
		}
		return err
	}

	return nil
}

// ContextValidate validate this o b write international standing order consent6 data initiation debtor account based on the context it is used
func (m *OBWriteInternationalStandingOrderConsent6DataInitiationDebtorAccount) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

	if err := m.contextValidateIdentification(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateSchemeName(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateSecondaryIdentification(ctx, formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiationDebtorAccount) contextValidateIdentification(ctx context.Context, formats strfmt.Registry) error {

	if m.Identification != nil {
		if err := m.Identification.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("Data" + "." + "Initiation" + "." + "DebtorAccount" + "." + "Identification")
			}
			return err
		}
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiationDebtorAccount) contextValidateSchemeName(ctx context.Context, formats strfmt.Registry) error {

	if m.SchemeName != nil {
		if err := m.SchemeName.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("Data" + "." + "Initiation" + "." + "DebtorAccount" + "." + "SchemeName")
			}
			return err
		}
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiationDebtorAccount) contextValidateSecondaryIdentification(ctx context.Context, formats strfmt.Registry) error {

	if err := m.SecondaryIdentification.ContextValidate(ctx, formats); err != nil {
		if ve, ok := err.(*errors.Validation); ok {
			return ve.ValidateName("Data" + "." + "Initiation" + "." + "DebtorAccount" + "." + "SecondaryIdentification")
		}
		return err
	}

	return nil
}

// MarshalBinary interface implementation
func (m *OBWriteInternationalStandingOrderConsent6DataInitiationDebtorAccount) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *OBWriteInternationalStandingOrderConsent6DataInitiationDebtorAccount) UnmarshalBinary(b []byte) error {
	var res OBWriteInternationalStandingOrderConsent6DataInitiationDebtorAccount
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// OBWriteInternationalStandingOrderConsent6DataInitiationInstructedAmount Amount of money to be moved between the debtor and creditor, before deduction of charges, expressed in the currency as ordered by the initiating party.
// Usage: This amount has to be transported unchanged through the transaction chain.
//
// swagger:model OBWriteInternationalStandingOrderConsent6DataInitiationInstructedAmount
type OBWriteInternationalStandingOrderConsent6DataInitiationInstructedAmount struct {

	// amount
	// Required: true
	Amount *OBActiveCurrencyAndAmountSimpleType `json:"Amount"`

	// currency
	// Required: true
	Currency *ActiveOrHistoricCurrencyCode `json:"Currency"`
}

// Validate validates this o b write international standing order consent6 data initiation instructed amount
func (m *OBWriteInternationalStandingOrderConsent6DataInitiationInstructedAmount) Validate(formats strfmt.Registry) error {
	var res []error

	if err := m.validateAmount(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateCurrency(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiationInstructedAmount) validateAmount(formats strfmt.Registry) error {

	if err := validate.Required("Data"+"."+"Initiation"+"."+"InstructedAmount"+"."+"Amount", "body", m.Amount); err != nil {
		return err
	}

	if err := validate.Required("Data"+"."+"Initiation"+"."+"InstructedAmount"+"."+"Amount", "body", m.Amount); err != nil {
		return err
	}

	if m.Amount != nil {
		if err := m.Amount.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("Data" + "." + "Initiation" + "." + "InstructedAmount" + "." + "Amount")
			}
			return err
		}
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiationInstructedAmount) validateCurrency(formats strfmt.Registry) error {

	if err := validate.Required("Data"+"."+"Initiation"+"."+"InstructedAmount"+"."+"Currency", "body", m.Currency); err != nil {
		return err
	}

	if err := validate.Required("Data"+"."+"Initiation"+"."+"InstructedAmount"+"."+"Currency", "body", m.Currency); err != nil {
		return err
	}

	if m.Currency != nil {
		if err := m.Currency.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("Data" + "." + "Initiation" + "." + "InstructedAmount" + "." + "Currency")
			}
			return err
		}
	}

	return nil
}

// ContextValidate validate this o b write international standing order consent6 data initiation instructed amount based on the context it is used
func (m *OBWriteInternationalStandingOrderConsent6DataInitiationInstructedAmount) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

	if err := m.contextValidateAmount(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateCurrency(ctx, formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiationInstructedAmount) contextValidateAmount(ctx context.Context, formats strfmt.Registry) error {

	if m.Amount != nil {
		if err := m.Amount.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("Data" + "." + "Initiation" + "." + "InstructedAmount" + "." + "Amount")
			}
			return err
		}
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataInitiationInstructedAmount) contextValidateCurrency(ctx context.Context, formats strfmt.Registry) error {

	if m.Currency != nil {
		if err := m.Currency.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("Data" + "." + "Initiation" + "." + "InstructedAmount" + "." + "Currency")
			}
			return err
		}
	}

	return nil
}

// MarshalBinary interface implementation
func (m *OBWriteInternationalStandingOrderConsent6DataInitiationInstructedAmount) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *OBWriteInternationalStandingOrderConsent6DataInitiationInstructedAmount) UnmarshalBinary(b []byte) error {
	var res OBWriteInternationalStandingOrderConsent6DataInitiationInstructedAmount
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// OBWriteInternationalStandingOrderConsent6DataSCASupportData Supporting Data provided by TPP, when requesting SCA Exemption.
//
// swagger:model OBWriteInternationalStandingOrderConsent6DataSCASupportData
type OBWriteInternationalStandingOrderConsent6DataSCASupportData struct {

	// Specifies a character string with a maximum length of 40 characters.
	// Usage: This field indicates whether the PSU was subject to SCA performed by the TPP
	// Enum: [CA SCA]
	AppliedAuthenticationApproach string `json:"AppliedAuthenticationApproach,omitempty"`

	// Specifies a character string with a maximum length of 140 characters.
	// Usage: If the payment is recurring then the transaction identifier of the previous payment occurrence so that the ASPSP can verify that the PISP, amount and the payee are the same as the previous occurrence.
	// Max Length: 128
	// Min Length: 1
	ReferencePaymentOrderID string `json:"ReferencePaymentOrderId,omitempty"`

	// This field allows a PISP to request specific SCA Exemption for a Payment Initiation
	// Enum: [BillPayment ContactlessTravel EcommerceGoods EcommerceServices Kiosk Parking PartyToParty]
	RequestedSCAExemptionType string `json:"RequestedSCAExemptionType,omitempty"`
}

// Validate validates this o b write international standing order consent6 data s c a support data
func (m *OBWriteInternationalStandingOrderConsent6DataSCASupportData) Validate(formats strfmt.Registry) error {
	var res []error

	if err := m.validateAppliedAuthenticationApproach(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateReferencePaymentOrderID(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateRequestedSCAExemptionType(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

var oBWriteInternationalStandingOrderConsent6DataSCASupportDataTypeAppliedAuthenticationApproachPropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["CA","SCA"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		oBWriteInternationalStandingOrderConsent6DataSCASupportDataTypeAppliedAuthenticationApproachPropEnum = append(oBWriteInternationalStandingOrderConsent6DataSCASupportDataTypeAppliedAuthenticationApproachPropEnum, v)
	}
}

const (

	// OBWriteInternationalStandingOrderConsent6DataSCASupportDataAppliedAuthenticationApproachCA captures enum value "CA"
	OBWriteInternationalStandingOrderConsent6DataSCASupportDataAppliedAuthenticationApproachCA string = "CA"

	// OBWriteInternationalStandingOrderConsent6DataSCASupportDataAppliedAuthenticationApproachSCA captures enum value "SCA"
	OBWriteInternationalStandingOrderConsent6DataSCASupportDataAppliedAuthenticationApproachSCA string = "SCA"
)

// prop value enum
func (m *OBWriteInternationalStandingOrderConsent6DataSCASupportData) validateAppliedAuthenticationApproachEnum(path, location string, value string) error {
	if err := validate.EnumCase(path, location, value, oBWriteInternationalStandingOrderConsent6DataSCASupportDataTypeAppliedAuthenticationApproachPropEnum, true); err != nil {
		return err
	}
	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataSCASupportData) validateAppliedAuthenticationApproach(formats strfmt.Registry) error {
	if swag.IsZero(m.AppliedAuthenticationApproach) { // not required
		return nil
	}

	// value enum
	if err := m.validateAppliedAuthenticationApproachEnum("Data"+"."+"SCASupportData"+"."+"AppliedAuthenticationApproach", "body", m.AppliedAuthenticationApproach); err != nil {
		return err
	}

	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataSCASupportData) validateReferencePaymentOrderID(formats strfmt.Registry) error {
	if swag.IsZero(m.ReferencePaymentOrderID) { // not required
		return nil
	}

	if err := validate.MinLength("Data"+"."+"SCASupportData"+"."+"ReferencePaymentOrderId", "body", m.ReferencePaymentOrderID, 1); err != nil {
		return err
	}

	if err := validate.MaxLength("Data"+"."+"SCASupportData"+"."+"ReferencePaymentOrderId", "body", m.ReferencePaymentOrderID, 128); err != nil {
		return err
	}

	return nil
}

var oBWriteInternationalStandingOrderConsent6DataSCASupportDataTypeRequestedSCAExemptionTypePropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["BillPayment","ContactlessTravel","EcommerceGoods","EcommerceServices","Kiosk","Parking","PartyToParty"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		oBWriteInternationalStandingOrderConsent6DataSCASupportDataTypeRequestedSCAExemptionTypePropEnum = append(oBWriteInternationalStandingOrderConsent6DataSCASupportDataTypeRequestedSCAExemptionTypePropEnum, v)
	}
}

const (

	// OBWriteInternationalStandingOrderConsent6DataSCASupportDataRequestedSCAExemptionTypeBillPayment captures enum value "BillPayment"
	OBWriteInternationalStandingOrderConsent6DataSCASupportDataRequestedSCAExemptionTypeBillPayment string = "BillPayment"

	// OBWriteInternationalStandingOrderConsent6DataSCASupportDataRequestedSCAExemptionTypeContactlessTravel captures enum value "ContactlessTravel"
	OBWriteInternationalStandingOrderConsent6DataSCASupportDataRequestedSCAExemptionTypeContactlessTravel string = "ContactlessTravel"

	// OBWriteInternationalStandingOrderConsent6DataSCASupportDataRequestedSCAExemptionTypeEcommerceGoods captures enum value "EcommerceGoods"
	OBWriteInternationalStandingOrderConsent6DataSCASupportDataRequestedSCAExemptionTypeEcommerceGoods string = "EcommerceGoods"

	// OBWriteInternationalStandingOrderConsent6DataSCASupportDataRequestedSCAExemptionTypeEcommerceServices captures enum value "EcommerceServices"
	OBWriteInternationalStandingOrderConsent6DataSCASupportDataRequestedSCAExemptionTypeEcommerceServices string = "EcommerceServices"

	// OBWriteInternationalStandingOrderConsent6DataSCASupportDataRequestedSCAExemptionTypeKiosk captures enum value "Kiosk"
	OBWriteInternationalStandingOrderConsent6DataSCASupportDataRequestedSCAExemptionTypeKiosk string = "Kiosk"

	// OBWriteInternationalStandingOrderConsent6DataSCASupportDataRequestedSCAExemptionTypeParking captures enum value "Parking"
	OBWriteInternationalStandingOrderConsent6DataSCASupportDataRequestedSCAExemptionTypeParking string = "Parking"

	// OBWriteInternationalStandingOrderConsent6DataSCASupportDataRequestedSCAExemptionTypePartyToParty captures enum value "PartyToParty"
	OBWriteInternationalStandingOrderConsent6DataSCASupportDataRequestedSCAExemptionTypePartyToParty string = "PartyToParty"
)

// prop value enum
func (m *OBWriteInternationalStandingOrderConsent6DataSCASupportData) validateRequestedSCAExemptionTypeEnum(path, location string, value string) error {
	if err := validate.EnumCase(path, location, value, oBWriteInternationalStandingOrderConsent6DataSCASupportDataTypeRequestedSCAExemptionTypePropEnum, true); err != nil {
		return err
	}
	return nil
}

func (m *OBWriteInternationalStandingOrderConsent6DataSCASupportData) validateRequestedSCAExemptionType(formats strfmt.Registry) error {
	if swag.IsZero(m.RequestedSCAExemptionType) { // not required
		return nil
	}

	// value enum
	if err := m.validateRequestedSCAExemptionTypeEnum("Data"+"."+"SCASupportData"+"."+"RequestedSCAExemptionType", "body", m.RequestedSCAExemptionType); err != nil {
		return err
	}

	return nil
}

// ContextValidate validates this o b write international standing order consent6 data s c a support data based on context it is used
func (m *OBWriteInternationalStandingOrderConsent6DataSCASupportData) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (m *OBWriteInternationalStandingOrderConsent6DataSCASupportData) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *OBWriteInternationalStandingOrderConsent6DataSCASupportData) UnmarshalBinary(b []byte) error {
	var res OBWriteInternationalStandingOrderConsent6DataSCASupportData
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}