o_b_write_international_scheduled_consent_response6.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"
	"strconv"

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

// OBWriteInternationalScheduledConsentResponse6 o b write international scheduled consent response6
//
// swagger:model OBWriteInternationalScheduledConsentResponse6
type OBWriteInternationalScheduledConsentResponse6 struct {

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

	// links
	Links *Links `json:"Links,omitempty"`

	// meta
	Meta *Meta `json:"Meta,omitempty"`

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

// Validate validates this o b write international scheduled consent response6
func (m *OBWriteInternationalScheduledConsentResponse6) Validate(formats strfmt.Registry) error {
	var res []error

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

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

	if err := m.validateMeta(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 *OBWriteInternationalScheduledConsentResponse6) 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 *OBWriteInternationalScheduledConsentResponse6) validateLinks(formats strfmt.Registry) error {
	if swag.IsZero(m.Links) { // not required
		return nil
	}

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

	return nil
}

func (m *OBWriteInternationalScheduledConsentResponse6) validateMeta(formats strfmt.Registry) error {
	if swag.IsZero(m.Meta) { // not required
		return nil
	}

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

	return nil
}

func (m *OBWriteInternationalScheduledConsentResponse6) 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 scheduled consent response6 based on the context it is used
func (m *OBWriteInternationalScheduledConsentResponse6) 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.contextValidateLinks(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateMeta(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 *OBWriteInternationalScheduledConsentResponse6) 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 *OBWriteInternationalScheduledConsentResponse6) contextValidateLinks(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

func (m *OBWriteInternationalScheduledConsentResponse6) contextValidateMeta(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

func (m *OBWriteInternationalScheduledConsentResponse6) 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 *OBWriteInternationalScheduledConsentResponse6) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

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

// OBWriteInternationalScheduledConsentResponse6Data o b write international scheduled consent response6 data
//
// swagger:model OBWriteInternationalScheduledConsentResponse6Data
type OBWriteInternationalScheduledConsentResponse6Data struct {

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

	// charges
	Charges []*OBWriteInternationalScheduledConsentResponse6DataChargesItems0 `json:"Charges"`

	// OB: Unique identification as assigned by the ASPSP to uniquely identify the consent resource.
	// Required: true
	// Max Length: 128
	// Min Length: 1
	ConsentID *string `json:"ConsentId"`

	// Date and time at which the resource was created.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
	CreationDateTime *strfmt.DateTime `json:"CreationDateTime"`

	// Specified cut-off date and time for the payment consent.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
	CutOffDateTime strfmt.DateTime `json:"CutOffDateTime,omitempty"`

	// debtor
	Debtor *OBDebtorIdentification1 `json:"Debtor,omitempty"`

	// exchange rate information
	ExchangeRateInformation *OBWriteInternationalScheduledConsentResponse6DataExchangeRateInformation `json:"ExchangeRateInformation,omitempty"`

	// Expected execution date and time for the payment resource.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
	ExpectedExecutionDateTime strfmt.DateTime `json:"ExpectedExecutionDateTime,omitempty"`

	// Expected settlement date and time for the payment resource.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
	ExpectedSettlementDateTime strfmt.DateTime `json:"ExpectedSettlementDateTime,omitempty"`

	// initiation
	// Required: true
	Initiation *OBWriteInternationalScheduledConsentResponse6DataInitiation `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 *OBWriteInternationalScheduledConsentResponse6DataSCASupportData `json:"SCASupportData,omitempty"`

	// Specifies the status of consent resource in code form.
	// Required: true
	// Enum: [Authorised AwaitingAuthorisation Consumed Rejected]
	Status *string `json:"Status"`

	// Date and time at which the resource status was updated.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
	StatusUpdateDateTime *strfmt.DateTime `json:"StatusUpdateDateTime"`
}

// Validate validates this o b write international scheduled consent response6 data
func (m *OBWriteInternationalScheduledConsentResponse6Data) Validate(formats strfmt.Registry) error {
	var res []error

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

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

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

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

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

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

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

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

	if err := m.validateExpectedSettlementDateTime(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 err := m.validateStatus(formats); err != nil {
		res = append(res, err)
	}

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

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

func (m *OBWriteInternationalScheduledConsentResponse6Data) 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 *OBWriteInternationalScheduledConsentResponse6Data) validateCharges(formats strfmt.Registry) error {
	if swag.IsZero(m.Charges) { // not required
		return nil
	}

	for i := 0; i < len(m.Charges); i++ {
		if swag.IsZero(m.Charges[i]) { // not required
			continue
		}

		if m.Charges[i] != nil {
			if err := m.Charges[i].Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("Data" + "." + "Charges" + "." + strconv.Itoa(i))
				}
				return err
			}
		}

	}

	return nil
}

func (m *OBWriteInternationalScheduledConsentResponse6Data) validateConsentID(formats strfmt.Registry) error {

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

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

	if err := validate.MaxLength("Data"+"."+"ConsentId", "body", *m.ConsentID, 128); err != nil {
		return err
	}

	return nil
}

func (m *OBWriteInternationalScheduledConsentResponse6Data) validateCreationDateTime(formats strfmt.Registry) error {

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

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

	return nil
}

func (m *OBWriteInternationalScheduledConsentResponse6Data) validateCutOffDateTime(formats strfmt.Registry) error {
	if swag.IsZero(m.CutOffDateTime) { // not required
		return nil
	}

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

	return nil
}

func (m *OBWriteInternationalScheduledConsentResponse6Data) validateDebtor(formats strfmt.Registry) error {
	if swag.IsZero(m.Debtor) { // not required
		return nil
	}

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

	return nil
}

func (m *OBWriteInternationalScheduledConsentResponse6Data) validateExchangeRateInformation(formats strfmt.Registry) error {
	if swag.IsZero(m.ExchangeRateInformation) { // not required
		return nil
	}

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

	return nil
}

func (m *OBWriteInternationalScheduledConsentResponse6Data) validateExpectedExecutionDateTime(formats strfmt.Registry) error {
	if swag.IsZero(m.ExpectedExecutionDateTime) { // not required
		return nil
	}

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

	return nil
}

func (m *OBWriteInternationalScheduledConsentResponse6Data) validateExpectedSettlementDateTime(formats strfmt.Registry) error {
	if swag.IsZero(m.ExpectedSettlementDateTime) { // not required
		return nil
	}

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

	return nil
}

func (m *OBWriteInternationalScheduledConsentResponse6Data) 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 oBWriteInternationalScheduledConsentResponse6DataTypePermissionPropEnum []interface{}

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

const (

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

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

func (m *OBWriteInternationalScheduledConsentResponse6Data) 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 oBWriteInternationalScheduledConsentResponse6DataTypeReadRefundAccountPropEnum []interface{}

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

const (

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

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

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

func (m *OBWriteInternationalScheduledConsentResponse6Data) 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 *OBWriteInternationalScheduledConsentResponse6Data) 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
}

var oBWriteInternationalScheduledConsentResponse6DataTypeStatusPropEnum []interface{}

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

const (

	// OBWriteInternationalScheduledConsentResponse6DataStatusAuthorised captures enum value "Authorised"
	OBWriteInternationalScheduledConsentResponse6DataStatusAuthorised string = "Authorised"

	// OBWriteInternationalScheduledConsentResponse6DataStatusAwaitingAuthorisation captures enum value "AwaitingAuthorisation"
	OBWriteInternationalScheduledConsentResponse6DataStatusAwaitingAuthorisation string = "AwaitingAuthorisation"

	// OBWriteInternationalScheduledConsentResponse6DataStatusConsumed captures enum value "Consumed"
	OBWriteInternationalScheduledConsentResponse6DataStatusConsumed string = "Consumed"

	// OBWriteInternationalScheduledConsentResponse6DataStatusRejected captures enum value "Rejected"
	OBWriteInternationalScheduledConsentResponse6DataStatusRejected string = "Rejected"
)

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

func (m *OBWriteInternationalScheduledConsentResponse6Data) validateStatus(formats strfmt.Registry) error {

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

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

	return nil
}

func (m *OBWriteInternationalScheduledConsentResponse6Data) validateStatusUpdateDateTime(formats strfmt.Registry) error {

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

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

	return nil
}

// ContextValidate validate this o b write international scheduled consent response6 data based on the context it is used
func (m *OBWriteInternationalScheduledConsentResponse6Data) 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.contextValidateCharges(ctx, formats); err != nil {
		res = append(res, err)
	}

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

	if err := m.contextValidateExchangeRateInformation(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 *OBWriteInternationalScheduledConsentResponse6Data) 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 *OBWriteInternationalScheduledConsentResponse6Data) contextValidateCharges(ctx context.Context, formats strfmt.Registry) error {

	for i := 0; i < len(m.Charges); i++ {

		if m.Charges[i] != nil {
			if err := m.Charges[i].ContextValidate(ctx, formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("Data" + "." + "Charges" + "." + strconv.Itoa(i))
				}
				return err
			}
		}

	}

	return nil
}

func (m *OBWriteInternationalScheduledConsentResponse6Data) contextValidateDebtor(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

func (m *OBWriteInternationalScheduledConsentResponse6Data) contextValidateExchangeRateInformation(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

func (m *OBWriteInternationalScheduledConsentResponse6Data) 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 *OBWriteInternationalScheduledConsentResponse6Data) 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 *OBWriteInternationalScheduledConsentResponse6Data) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

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

// OBWriteInternationalScheduledConsentResponse6DataAuthorisation The authorisation type request from the TPP.
//
// swagger:model OBWriteInternationalScheduledConsentResponse6DataAuthorisation
type OBWriteInternationalScheduledConsentResponse6DataAuthorisation 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 scheduled consent response6 data authorisation
func (m *OBWriteInternationalScheduledConsentResponse6DataAuthorisation) 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 oBWriteInternationalScheduledConsentResponse6DataAuthorisationTypeAuthorisationTypePropEnum []interface{}

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

const (

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

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

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

func (m *OBWriteInternationalScheduledConsentResponse6DataAuthorisation) 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 *OBWriteInternationalScheduledConsentResponse6DataAuthorisation) 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 scheduled consent response6 data authorisation based on context it is used
func (m *OBWriteInternationalScheduledConsentResponse6DataAuthorisation) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

// OBWriteInternationalScheduledConsentResponse6DataChargesItems0 Set of elements used to provide details of a charge for the payment initiation.
//
// swagger:model OBWriteInternationalScheduledConsentResponse6DataChargesItems0
type OBWriteInternationalScheduledConsentResponse6DataChargesItems0 struct {

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

	// charge bearer
	// Required: true
	ChargeBearer *OBChargeBearerType1Code `json:"ChargeBearer"`

	// type
	// Required: true
	Type *OBExternalPaymentChargeType1Code `json:"Type"`
}

// Validate validates this o b write international scheduled consent response6 data charges items0
func (m *OBWriteInternationalScheduledConsentResponse6DataChargesItems0) Validate(formats strfmt.Registry) error {
	var res []error

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

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

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

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

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

	if err := validate.Required("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("Amount")
			}
			return err
		}
	}

	return nil
}

func (m *OBWriteInternationalScheduledConsentResponse6DataChargesItems0) validateChargeBearer(formats strfmt.Registry) error {

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

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

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

	return nil
}

func (m *OBWriteInternationalScheduledConsentResponse6DataChargesItems0) validateType(formats strfmt.Registry) error {

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

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

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

	return nil
}

// ContextValidate validate this o b write international scheduled consent response6 data charges items0 based on the context it is used
func (m *OBWriteInternationalScheduledConsentResponse6DataChargesItems0) 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.contextValidateChargeBearer(ctx, formats); err != nil {
		res = append(res, err)
	}

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

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

func (m *OBWriteInternationalScheduledConsentResponse6DataChargesItems0) 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("Amount")
			}
			return err
		}
	}

	return nil
}

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

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

	return nil
}

func (m *OBWriteInternationalScheduledConsentResponse6DataChargesItems0) contextValidateType(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

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

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

// OBWriteInternationalScheduledConsentResponse6DataExchangeRateInformation Further detailed information on the exchange rate that has been used in the payment transaction.
//
// swagger:model OBWriteInternationalScheduledConsentResponse6DataExchangeRateInformation
type OBWriteInternationalScheduledConsentResponse6DataExchangeRateInformation struct {

	// Unique and unambiguous reference to the foreign exchange contract agreed between the initiating party/creditor and the debtor agent.
	// Max Length: 256
	// Min Length: 1
	ContractIdentification string `json:"ContractIdentification,omitempty"`

	// The factor used for conversion of an amount from one currency to another. This reflects the price at which one currency was bought with another currency.
	// Required: true
	ExchangeRate *float64 `json:"ExchangeRate"`

	// Specified date and time the exchange rate agreement will expire.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
	ExpirationDateTime strfmt.DateTime `json:"ExpirationDateTime,omitempty"`

	// Specifies the type used to complete the currency exchange.
	// Required: true
	// Enum: [Actual Agreed Indicative]
	RateType *string `json:"RateType"`

	// Currency in which the rate of exchange is expressed in a currency exchange. In the example 1GBP = xxxCUR, the unit currency is GBP.
	// Required: true
	// Pattern: ^[A-Z]{3,3}$
	UnitCurrency *string `json:"UnitCurrency"`
}

// Validate validates this o b write international scheduled consent response6 data exchange rate information
func (m *OBWriteInternationalScheduledConsentResponse6DataExchangeRateInformation) Validate(formats strfmt.Registry) error {
	var res []error

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

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

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

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

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

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

func (m *OBWriteInternationalScheduledConsentResponse6DataExchangeRateInformation) validateContractIdentification(formats strfmt.Registry) error {
	if swag.IsZero(m.ContractIdentification) { // not required
		return nil
	}

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

	if err := validate.MaxLength("Data"+"."+"ExchangeRateInformation"+"."+"ContractIdentification", "body", m.ContractIdentification, 256); err != nil {
		return err
	}

	return nil
}

func (m *OBWriteInternationalScheduledConsentResponse6DataExchangeRateInformation) validateExchangeRate(formats strfmt.Registry) error {

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

	return nil
}

func (m *OBWriteInternationalScheduledConsentResponse6DataExchangeRateInformation) validateExpirationDateTime(formats strfmt.Registry) error {
	if swag.IsZero(m.ExpirationDateTime) { // not required
		return nil
	}

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

	return nil
}

var oBWriteInternationalScheduledConsentResponse6DataExchangeRateInformationTypeRateTypePropEnum []interface{}

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

const (

	// OBWriteInternationalScheduledConsentResponse6DataExchangeRateInformationRateTypeActual captures enum value "Actual"
	OBWriteInternationalScheduledConsentResponse6DataExchangeRateInformationRateTypeActual string = "Actual"

	// OBWriteInternationalScheduledConsentResponse6DataExchangeRateInformationRateTypeAgreed captures enum value "Agreed"
	OBWriteInternationalScheduledConsentResponse6DataExchangeRateInformationRateTypeAgreed string = "Agreed"

	// OBWriteInternationalScheduledConsentResponse6DataExchangeRateInformationRateTypeIndicative captures enum value "Indicative"
	OBWriteInternationalScheduledConsentResponse6DataExchangeRateInformationRateTypeIndicative string = "Indicative"
)

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

func (m *OBWriteInternationalScheduledConsentResponse6DataExchangeRateInformation) validateRateType(formats strfmt.Registry) error {

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

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

	return nil
}

func (m *OBWriteInternationalScheduledConsentResponse6DataExchangeRateInformation) validateUnitCurrency(formats strfmt.Registry) error {

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

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

	return nil
}

// ContextValidate validates this o b write international scheduled consent response6 data exchange rate information based on context it is used
func (m *OBWriteInternationalScheduledConsentResponse6DataExchangeRateInformation) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

// OBWriteInternationalScheduledConsentResponse6DataInitiation 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 a single scheduled international payment.
//
// swagger:model OBWriteInternationalScheduledConsentResponse6DataInitiation
type OBWriteInternationalScheduledConsentResponse6DataInitiation struct {

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

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

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

	// creditor agent
	CreditorAgent *OBWriteInternationalScheduledConsentResponse6DataInitiationCreditorAgent `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 *OBWriteInternationalScheduledConsentResponse6DataInitiationDebtorAccount `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"`

	// Unique identification assigned by the initiating party to unambiguously identify the transaction. This identification is passed on, unchanged, throughout the entire end-to-end chain.
	// Usage: The end-to-end identification can be used for reconciliation or to link tasks relating to the transaction. It can be included in several messages related to the transaction.
	// OB: The Faster Payments Scheme can only access 31 characters for the EndToEndIdentification field.
	// Max Length: 35
	// Min Length: 1
	EndToEndIdentification string `json:"EndToEndIdentification,omitempty"`

	// exchange rate information
	ExchangeRateInformation *OBWriteInternationalScheduledConsentResponse6DataInitiationExchangeRateInformation `json:"ExchangeRateInformation,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"`

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

	// Unique identification as assigned by an instructing party for an instructed party to unambiguously identify the instruction.
	// Usage: the  instruction identification is a point to point reference that can be used between the instructing party and the instructed party to refer to the individual instruction. It can be included in several messages related to the instruction.
	// Required: true
	// Max Length: 35
	// Min Length: 1
	InstructionIdentification *string `json:"InstructionIdentification"`

	// Indicator of the urgency or order of importance that the instructing party would like the instructed party to apply to the processing of the instruction.
	// Enum: [Normal Urgent]
	InstructionPriority string `json:"InstructionPriority,omitempty"`

	// local instrument
	LocalInstrument OBExternalLocalInstrument1Code `json:"LocalInstrument,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"`

	// remittance information
	RemittanceInformation *OBWriteInternationalScheduledConsentResponse6DataInitiationRemittanceInformation `json:"RemittanceInformation,omitempty"`

	// Date at which the initiating party requests the clearing agent to process the payment.
	// Usage: This is the date on which the debtor's account is to be debited.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
	RequestedExecutionDateTime *strfmt.DateTime `json:"RequestedExecutionDateTime"`

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

// Validate validates this o b write international scheduled consent response6 data initiation
func (m *OBWriteInternationalScheduledConsentResponse6DataInitiation) 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.validateEndToEndIdentification(formats); err != nil {
		res = append(res, err)
	}

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

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

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

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

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

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

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

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

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

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

func (m *OBWriteInternationalScheduledConsentResponse6DataInitiation) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiation) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiation) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiation) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiation) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiation) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiation) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiation) validateEndToEndIdentification(formats strfmt.Registry) error {
	if swag.IsZero(m.EndToEndIdentification) { // not required
		return nil
	}

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

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

	return nil
}

func (m *OBWriteInternationalScheduledConsentResponse6DataInitiation) validateExchangeRateInformation(formats strfmt.Registry) error {
	if swag.IsZero(m.ExchangeRateInformation) { // not required
		return nil
	}

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

	return nil
}

func (m *OBWriteInternationalScheduledConsentResponse6DataInitiation) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiation) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiation) validateInstructionIdentification(formats strfmt.Registry) error {

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

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

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

	return nil
}

var oBWriteInternationalScheduledConsentResponse6DataInitiationTypeInstructionPriorityPropEnum []interface{}

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

const (

	// OBWriteInternationalScheduledConsentResponse6DataInitiationInstructionPriorityNormal captures enum value "Normal"
	OBWriteInternationalScheduledConsentResponse6DataInitiationInstructionPriorityNormal string = "Normal"

	// OBWriteInternationalScheduledConsentResponse6DataInitiationInstructionPriorityUrgent captures enum value "Urgent"
	OBWriteInternationalScheduledConsentResponse6DataInitiationInstructionPriorityUrgent string = "Urgent"
)

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

func (m *OBWriteInternationalScheduledConsentResponse6DataInitiation) validateInstructionPriority(formats strfmt.Registry) error {
	if swag.IsZero(m.InstructionPriority) { // not required
		return nil
	}

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

	return nil
}

func (m *OBWriteInternationalScheduledConsentResponse6DataInitiation) validateLocalInstrument(formats strfmt.Registry) error {
	if swag.IsZero(m.LocalInstrument) { // not required
		return nil
	}

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

	return nil
}

func (m *OBWriteInternationalScheduledConsentResponse6DataInitiation) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiation) validateRemittanceInformation(formats strfmt.Registry) error {
	if swag.IsZero(m.RemittanceInformation) { // not required
		return nil
	}

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

	return nil
}

func (m *OBWriteInternationalScheduledConsentResponse6DataInitiation) validateRequestedExecutionDateTime(formats strfmt.Registry) error {

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

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

	return nil
}

// ContextValidate validate this o b write international scheduled consent response6 data initiation based on the context it is used
func (m *OBWriteInternationalScheduledConsentResponse6DataInitiation) 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.contextValidateExchangeRateInformation(ctx, formats); err != nil {
		res = append(res, err)
	}

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

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

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

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

func (m *OBWriteInternationalScheduledConsentResponse6DataInitiation) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiation) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiation) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiation) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiation) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiation) contextValidateExchangeRateInformation(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

func (m *OBWriteInternationalScheduledConsentResponse6DataInitiation) 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
}

func (m *OBWriteInternationalScheduledConsentResponse6DataInitiation) contextValidateLocalInstrument(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

func (m *OBWriteInternationalScheduledConsentResponse6DataInitiation) contextValidateRemittanceInformation(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

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

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

// OBWriteInternationalScheduledConsentResponse6DataInitiationCreditor Party to which an amount of money is due.
//
// swagger:model OBWriteInternationalScheduledConsentResponse6DataInitiationCreditor
type OBWriteInternationalScheduledConsentResponse6DataInitiationCreditor 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 scheduled consent response6 data initiation creditor
func (m *OBWriteInternationalScheduledConsentResponse6DataInitiationCreditor) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiationCreditor) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiationCreditor) 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 scheduled consent response6 data initiation creditor based on the context it is used
func (m *OBWriteInternationalScheduledConsentResponse6DataInitiationCreditor) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiationCreditor) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiationCreditor) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

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

// OBWriteInternationalScheduledConsentResponse6DataInitiationCreditorAccount Unambiguous identification of the account of the creditor to which a credit entry will be posted as a result of the payment transaction.
//
// swagger:model OBWriteInternationalScheduledConsentResponse6DataInitiationCreditorAccount
type OBWriteInternationalScheduledConsentResponse6DataInitiationCreditorAccount 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 scheduled consent response6 data initiation creditor account
func (m *OBWriteInternationalScheduledConsentResponse6DataInitiationCreditorAccount) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiationCreditorAccount) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiationCreditorAccount) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiationCreditorAccount) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiationCreditorAccount) 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 scheduled consent response6 data initiation creditor account based on the context it is used
func (m *OBWriteInternationalScheduledConsentResponse6DataInitiationCreditorAccount) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiationCreditorAccount) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiationCreditorAccount) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiationCreditorAccount) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiationCreditorAccount) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

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

// OBWriteInternationalScheduledConsentResponse6DataInitiationCreditorAgent Financial institution servicing an account for the creditor.
//
// swagger:model OBWriteInternationalScheduledConsentResponse6DataInitiationCreditorAgent
type OBWriteInternationalScheduledConsentResponse6DataInitiationCreditorAgent struct {

	// identification
	Identification Identification1 `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 scheduled consent response6 data initiation creditor agent
func (m *OBWriteInternationalScheduledConsentResponse6DataInitiationCreditorAgent) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiationCreditorAgent) validateIdentification(formats strfmt.Registry) error {
	if swag.IsZero(m.Identification) { // not required
		return nil
	}

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

	return nil
}

func (m *OBWriteInternationalScheduledConsentResponse6DataInitiationCreditorAgent) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiationCreditorAgent) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiationCreditorAgent) 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 scheduled consent response6 data initiation creditor agent based on the context it is used
func (m *OBWriteInternationalScheduledConsentResponse6DataInitiationCreditorAgent) 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.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 *OBWriteInternationalScheduledConsentResponse6DataInitiationCreditorAgent) contextValidateIdentification(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

func (m *OBWriteInternationalScheduledConsentResponse6DataInitiationCreditorAgent) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiationCreditorAgent) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiationCreditorAgent) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiationCreditorAgent) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

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

// OBWriteInternationalScheduledConsentResponse6DataInitiationDebtorAccount Unambiguous identification of the account of the debtor to which a debit entry will be made as a result of the transaction.
//
// swagger:model OBWriteInternationalScheduledConsentResponse6DataInitiationDebtorAccount
type OBWriteInternationalScheduledConsentResponse6DataInitiationDebtorAccount 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 scheduled consent response6 data initiation debtor account
func (m *OBWriteInternationalScheduledConsentResponse6DataInitiationDebtorAccount) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiationDebtorAccount) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiationDebtorAccount) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiationDebtorAccount) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiationDebtorAccount) 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 scheduled consent response6 data initiation debtor account based on the context it is used
func (m *OBWriteInternationalScheduledConsentResponse6DataInitiationDebtorAccount) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiationDebtorAccount) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiationDebtorAccount) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiationDebtorAccount) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiationDebtorAccount) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

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

// OBWriteInternationalScheduledConsentResponse6DataInitiationExchangeRateInformation Provides details on the currency exchange rate and contract.
//
// swagger:model OBWriteInternationalScheduledConsentResponse6DataInitiationExchangeRateInformation
type OBWriteInternationalScheduledConsentResponse6DataInitiationExchangeRateInformation struct {

	// Unique and unambiguous reference to the foreign exchange contract agreed between the initiating party/creditor and the debtor agent.
	// Max Length: 256
	// Min Length: 1
	ContractIdentification string `json:"ContractIdentification,omitempty"`

	// The factor used for conversion of an amount from one currency to another. This reflects the price at which one currency was bought with another currency.
	ExchangeRate float64 `json:"ExchangeRate,omitempty"`

	// Specifies the type used to complete the currency exchange.
	// Required: true
	// Enum: [Actual Agreed Indicative]
	RateType *string `json:"RateType"`

	// Currency in which the rate of exchange is expressed in a currency exchange. In the example 1GBP = xxxCUR, the unit currency is GBP.
	// Required: true
	// Pattern: ^[A-Z]{3,3}$
	UnitCurrency *string `json:"UnitCurrency"`
}

// Validate validates this o b write international scheduled consent response6 data initiation exchange rate information
func (m *OBWriteInternationalScheduledConsentResponse6DataInitiationExchangeRateInformation) Validate(formats strfmt.Registry) error {
	var res []error

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

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

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

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

func (m *OBWriteInternationalScheduledConsentResponse6DataInitiationExchangeRateInformation) validateContractIdentification(formats strfmt.Registry) error {
	if swag.IsZero(m.ContractIdentification) { // not required
		return nil
	}

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

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

	return nil
}

var oBWriteInternationalScheduledConsentResponse6DataInitiationExchangeRateInformationTypeRateTypePropEnum []interface{}

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

const (

	// OBWriteInternationalScheduledConsentResponse6DataInitiationExchangeRateInformationRateTypeActual captures enum value "Actual"
	OBWriteInternationalScheduledConsentResponse6DataInitiationExchangeRateInformationRateTypeActual string = "Actual"

	// OBWriteInternationalScheduledConsentResponse6DataInitiationExchangeRateInformationRateTypeAgreed captures enum value "Agreed"
	OBWriteInternationalScheduledConsentResponse6DataInitiationExchangeRateInformationRateTypeAgreed string = "Agreed"

	// OBWriteInternationalScheduledConsentResponse6DataInitiationExchangeRateInformationRateTypeIndicative captures enum value "Indicative"
	OBWriteInternationalScheduledConsentResponse6DataInitiationExchangeRateInformationRateTypeIndicative string = "Indicative"
)

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

func (m *OBWriteInternationalScheduledConsentResponse6DataInitiationExchangeRateInformation) validateRateType(formats strfmt.Registry) error {

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

	// value enum
	if err := m.validateRateTypeEnum("Data"+"."+"Initiation"+"."+"ExchangeRateInformation"+"."+"RateType", "body", *m.RateType); err != nil {
		return err
	}

	return nil
}

func (m *OBWriteInternationalScheduledConsentResponse6DataInitiationExchangeRateInformation) validateUnitCurrency(formats strfmt.Registry) error {

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

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

	return nil
}

// ContextValidate validates this o b write international scheduled consent response6 data initiation exchange rate information based on context it is used
func (m *OBWriteInternationalScheduledConsentResponse6DataInitiationExchangeRateInformation) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

// OBWriteInternationalScheduledConsentResponse6DataInitiationInstructedAmount 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 OBWriteInternationalScheduledConsentResponse6DataInitiationInstructedAmount
type OBWriteInternationalScheduledConsentResponse6DataInitiationInstructedAmount struct {

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

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

// Validate validates this o b write international scheduled consent response6 data initiation instructed amount
func (m *OBWriteInternationalScheduledConsentResponse6DataInitiationInstructedAmount) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiationInstructedAmount) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiationInstructedAmount) 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 scheduled consent response6 data initiation instructed amount based on the context it is used
func (m *OBWriteInternationalScheduledConsentResponse6DataInitiationInstructedAmount) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiationInstructedAmount) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiationInstructedAmount) 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 *OBWriteInternationalScheduledConsentResponse6DataInitiationInstructedAmount) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

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

// OBWriteInternationalScheduledConsentResponse6DataInitiationRemittanceInformation Information supplied to enable the matching of an entry with the items that the transfer is intended to settle, such as commercial invoices in an accounts' receivable system.
//
// swagger:model OBWriteInternationalScheduledConsentResponse6DataInitiationRemittanceInformation
type OBWriteInternationalScheduledConsentResponse6DataInitiationRemittanceInformation struct {

	// 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.
	// OB: The Faster Payments Scheme can only accept 18 characters for the ReferenceInformation field - which is where this ISO field will be mapped.
	// Max Length: 35
	// Min Length: 1
	Reference string `json:"Reference,omitempty"`

	// Information supplied to enable the matching/reconciliation of an entry with the items that the payment is intended to settle, such as commercial invoices in an accounts' receivable system, in an unstructured form.
	// Max Length: 140
	// Min Length: 1
	Unstructured string `json:"Unstructured,omitempty"`
}

// Validate validates this o b write international scheduled consent response6 data initiation remittance information
func (m *OBWriteInternationalScheduledConsentResponse6DataInitiationRemittanceInformation) Validate(formats strfmt.Registry) error {
	var res []error

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

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

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

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

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

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

	return nil
}

func (m *OBWriteInternationalScheduledConsentResponse6DataInitiationRemittanceInformation) validateUnstructured(formats strfmt.Registry) error {
	if swag.IsZero(m.Unstructured) { // not required
		return nil
	}

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

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

	return nil
}

// ContextValidate validates this o b write international scheduled consent response6 data initiation remittance information based on context it is used
func (m *OBWriteInternationalScheduledConsentResponse6DataInitiationRemittanceInformation) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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

// OBWriteInternationalScheduledConsentResponse6DataSCASupportData Supporting Data provided by TPP, when requesting SCA Exemption.
//
// swagger:model OBWriteInternationalScheduledConsentResponse6DataSCASupportData
type OBWriteInternationalScheduledConsentResponse6DataSCASupportData 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 scheduled consent response6 data s c a support data
func (m *OBWriteInternationalScheduledConsentResponse6DataSCASupportData) 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 oBWriteInternationalScheduledConsentResponse6DataSCASupportDataTypeAppliedAuthenticationApproachPropEnum []interface{}

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

const (

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

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

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

func (m *OBWriteInternationalScheduledConsentResponse6DataSCASupportData) 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 *OBWriteInternationalScheduledConsentResponse6DataSCASupportData) 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 oBWriteInternationalScheduledConsentResponse6DataSCASupportDataTypeRequestedSCAExemptionTypePropEnum []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 {
		oBWriteInternationalScheduledConsentResponse6DataSCASupportDataTypeRequestedSCAExemptionTypePropEnum = append(oBWriteInternationalScheduledConsentResponse6DataSCASupportDataTypeRequestedSCAExemptionTypePropEnum, v)
	}
}

const (

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

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

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

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

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

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

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

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

func (m *OBWriteInternationalScheduledConsentResponse6DataSCASupportData) 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 scheduled consent response6 data s c a support data based on context it is used
func (m *OBWriteInternationalScheduledConsentResponse6DataSCASupportData) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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