messaging_service.pb.validate.go

// Code generated by protoc-gen-validate. DO NOT EDIT.
// source: messaging/v1/messaging_service.proto

package messaging

import (
	"bytes"
	"errors"
	"fmt"
	"net"
	"net/mail"
	"net/url"
	"regexp"
	"strings"
	"time"
	"unicode/utf8"

	"github.com/golang/protobuf/ptypes"

	transaction "github.com/code-payments/code-protobuf-api/generated/go/transaction/v2"
)

// ensure the imports are used
var (
	_ = bytes.MinRead
	_ = errors.New("")
	_ = fmt.Print
	_ = utf8.UTFMax
	_ = (*regexp.Regexp)(nil)
	_ = (*strings.Reader)(nil)
	_ = net.IPv4len
	_ = time.Duration(0)
	_ = (*url.URL)(nil)
	_ = (*mail.Address)(nil)
	_ = ptypes.DynamicAny{}

	_ = transaction.AirdropType(0)
)

// Validate checks the field values on OpenMessageStreamRequest with the rules
// defined in the proto definition for this message. If any rules are
// violated, an error is returned.
func (m *OpenMessageStreamRequest) Validate() error {
	if m == nil {
		return nil
	}

	if m.GetRendezvousKey() == nil {
		return OpenMessageStreamRequestValidationError{
			field:  "RendezvousKey",
			reason: "value is required",
		}
	}

	if v, ok := interface{}(m.GetRendezvousKey()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return OpenMessageStreamRequestValidationError{
				field:  "RendezvousKey",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if v, ok := interface{}(m.GetSignature()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return OpenMessageStreamRequestValidationError{
				field:  "Signature",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	return nil
}

// OpenMessageStreamRequestValidationError is the validation error returned by
// OpenMessageStreamRequest.Validate if the designated constraints aren't met.
type OpenMessageStreamRequestValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e OpenMessageStreamRequestValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e OpenMessageStreamRequestValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e OpenMessageStreamRequestValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e OpenMessageStreamRequestValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e OpenMessageStreamRequestValidationError) ErrorName() string {
	return "OpenMessageStreamRequestValidationError"
}

// Error satisfies the builtin error interface
func (e OpenMessageStreamRequestValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sOpenMessageStreamRequest.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = OpenMessageStreamRequestValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = OpenMessageStreamRequestValidationError{}

// Validate checks the field values on OpenMessageStreamResponse with the rules
// defined in the proto definition for this message. If any rules are
// violated, an error is returned.
func (m *OpenMessageStreamResponse) Validate() error {
	if m == nil {
		return nil
	}

	if l := len(m.GetMessages()); l < 1 || l > 1024 {
		return OpenMessageStreamResponseValidationError{
			field:  "Messages",
			reason: "value must contain between 1 and 1024 items, inclusive",
		}
	}

	for idx, item := range m.GetMessages() {
		_, _ = idx, item

		if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return OpenMessageStreamResponseValidationError{
					field:  fmt.Sprintf("Messages[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	return nil
}

// OpenMessageStreamResponseValidationError is the validation error returned by
// OpenMessageStreamResponse.Validate if the designated constraints aren't met.
type OpenMessageStreamResponseValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e OpenMessageStreamResponseValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e OpenMessageStreamResponseValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e OpenMessageStreamResponseValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e OpenMessageStreamResponseValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e OpenMessageStreamResponseValidationError) ErrorName() string {
	return "OpenMessageStreamResponseValidationError"
}

// Error satisfies the builtin error interface
func (e OpenMessageStreamResponseValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sOpenMessageStreamResponse.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = OpenMessageStreamResponseValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = OpenMessageStreamResponseValidationError{}

// Validate checks the field values on OpenMessageStreamWithKeepAliveRequest
// with the rules defined in the proto definition for this message. If any
// rules are violated, an error is returned.
func (m *OpenMessageStreamWithKeepAliveRequest) Validate() error {
	if m == nil {
		return nil
	}

	switch m.RequestOrPong.(type) {

	case *OpenMessageStreamWithKeepAliveRequest_Request:

		if v, ok := interface{}(m.GetRequest()).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return OpenMessageStreamWithKeepAliveRequestValidationError{
					field:  "Request",
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	case *OpenMessageStreamWithKeepAliveRequest_Pong:

		if v, ok := interface{}(m.GetPong()).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return OpenMessageStreamWithKeepAliveRequestValidationError{
					field:  "Pong",
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	default:
		return OpenMessageStreamWithKeepAliveRequestValidationError{
			field:  "RequestOrPong",
			reason: "value is required",
		}

	}

	return nil
}

// OpenMessageStreamWithKeepAliveRequestValidationError is the validation error
// returned by OpenMessageStreamWithKeepAliveRequest.Validate if the
// designated constraints aren't met.
type OpenMessageStreamWithKeepAliveRequestValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e OpenMessageStreamWithKeepAliveRequestValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e OpenMessageStreamWithKeepAliveRequestValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e OpenMessageStreamWithKeepAliveRequestValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e OpenMessageStreamWithKeepAliveRequestValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e OpenMessageStreamWithKeepAliveRequestValidationError) ErrorName() string {
	return "OpenMessageStreamWithKeepAliveRequestValidationError"
}

// Error satisfies the builtin error interface
func (e OpenMessageStreamWithKeepAliveRequestValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sOpenMessageStreamWithKeepAliveRequest.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = OpenMessageStreamWithKeepAliveRequestValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = OpenMessageStreamWithKeepAliveRequestValidationError{}

// Validate checks the field values on OpenMessageStreamWithKeepAliveResponse
// with the rules defined in the proto definition for this message. If any
// rules are violated, an error is returned.
func (m *OpenMessageStreamWithKeepAliveResponse) Validate() error {
	if m == nil {
		return nil
	}

	switch m.ResponseOrPing.(type) {

	case *OpenMessageStreamWithKeepAliveResponse_Response:

		if v, ok := interface{}(m.GetResponse()).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return OpenMessageStreamWithKeepAliveResponseValidationError{
					field:  "Response",
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	case *OpenMessageStreamWithKeepAliveResponse_Ping:

		if v, ok := interface{}(m.GetPing()).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return OpenMessageStreamWithKeepAliveResponseValidationError{
					field:  "Ping",
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	default:
		return OpenMessageStreamWithKeepAliveResponseValidationError{
			field:  "ResponseOrPing",
			reason: "value is required",
		}

	}

	return nil
}

// OpenMessageStreamWithKeepAliveResponseValidationError is the validation
// error returned by OpenMessageStreamWithKeepAliveResponse.Validate if the
// designated constraints aren't met.
type OpenMessageStreamWithKeepAliveResponseValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e OpenMessageStreamWithKeepAliveResponseValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e OpenMessageStreamWithKeepAliveResponseValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e OpenMessageStreamWithKeepAliveResponseValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e OpenMessageStreamWithKeepAliveResponseValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e OpenMessageStreamWithKeepAliveResponseValidationError) ErrorName() string {
	return "OpenMessageStreamWithKeepAliveResponseValidationError"
}

// Error satisfies the builtin error interface
func (e OpenMessageStreamWithKeepAliveResponseValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sOpenMessageStreamWithKeepAliveResponse.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = OpenMessageStreamWithKeepAliveResponseValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = OpenMessageStreamWithKeepAliveResponseValidationError{}

// Validate checks the field values on PollMessagesRequest with the rules
// defined in the proto definition for this message. If any rules are
// violated, an error is returned.
func (m *PollMessagesRequest) Validate() error {
	if m == nil {
		return nil
	}

	if m.GetRendezvousKey() == nil {
		return PollMessagesRequestValidationError{
			field:  "RendezvousKey",
			reason: "value is required",
		}
	}

	if v, ok := interface{}(m.GetRendezvousKey()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return PollMessagesRequestValidationError{
				field:  "RendezvousKey",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if m.GetSignature() == nil {
		return PollMessagesRequestValidationError{
			field:  "Signature",
			reason: "value is required",
		}
	}

	if v, ok := interface{}(m.GetSignature()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return PollMessagesRequestValidationError{
				field:  "Signature",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	return nil
}

// PollMessagesRequestValidationError is the validation error returned by
// PollMessagesRequest.Validate if the designated constraints aren't met.
type PollMessagesRequestValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e PollMessagesRequestValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e PollMessagesRequestValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e PollMessagesRequestValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e PollMessagesRequestValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e PollMessagesRequestValidationError) ErrorName() string {
	return "PollMessagesRequestValidationError"
}

// Error satisfies the builtin error interface
func (e PollMessagesRequestValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sPollMessagesRequest.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = PollMessagesRequestValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = PollMessagesRequestValidationError{}

// Validate checks the field values on PollMessagesResponse with the rules
// defined in the proto definition for this message. If any rules are
// violated, an error is returned.
func (m *PollMessagesResponse) Validate() error {
	if m == nil {
		return nil
	}

	if len(m.GetMessages()) > 1024 {
		return PollMessagesResponseValidationError{
			field:  "Messages",
			reason: "value must contain no more than 1024 item(s)",
		}
	}

	for idx, item := range m.GetMessages() {
		_, _ = idx, item

		if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return PollMessagesResponseValidationError{
					field:  fmt.Sprintf("Messages[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	return nil
}

// PollMessagesResponseValidationError is the validation error returned by
// PollMessagesResponse.Validate if the designated constraints aren't met.
type PollMessagesResponseValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e PollMessagesResponseValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e PollMessagesResponseValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e PollMessagesResponseValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e PollMessagesResponseValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e PollMessagesResponseValidationError) ErrorName() string {
	return "PollMessagesResponseValidationError"
}

// Error satisfies the builtin error interface
func (e PollMessagesResponseValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sPollMessagesResponse.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = PollMessagesResponseValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = PollMessagesResponseValidationError{}

// Validate checks the field values on AckMessagesRequest with the rules
// defined in the proto definition for this message. If any rules are
// violated, an error is returned.
func (m *AckMessagesRequest) Validate() error {
	if m == nil {
		return nil
	}

	if m.GetRendezvousKey() == nil {
		return AckMessagesRequestValidationError{
			field:  "RendezvousKey",
			reason: "value is required",
		}
	}

	if v, ok := interface{}(m.GetRendezvousKey()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return AckMessagesRequestValidationError{
				field:  "RendezvousKey",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if l := len(m.GetMessageIds()); l < 1 || l > 1024 {
		return AckMessagesRequestValidationError{
			field:  "MessageIds",
			reason: "value must contain between 1 and 1024 items, inclusive",
		}
	}

	for idx, item := range m.GetMessageIds() {
		_, _ = idx, item

		if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return AckMessagesRequestValidationError{
					field:  fmt.Sprintf("MessageIds[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	return nil
}

// AckMessagesRequestValidationError is the validation error returned by
// AckMessagesRequest.Validate if the designated constraints aren't met.
type AckMessagesRequestValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e AckMessagesRequestValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e AckMessagesRequestValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e AckMessagesRequestValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e AckMessagesRequestValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e AckMessagesRequestValidationError) ErrorName() string {
	return "AckMessagesRequestValidationError"
}

// Error satisfies the builtin error interface
func (e AckMessagesRequestValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sAckMessagesRequest.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = AckMessagesRequestValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = AckMessagesRequestValidationError{}

// Validate checks the field values on AckMesssagesResponse with the rules
// defined in the proto definition for this message. If any rules are
// violated, an error is returned.
func (m *AckMesssagesResponse) Validate() error {
	if m == nil {
		return nil
	}

	// no validation rules for Result

	return nil
}

// AckMesssagesResponseValidationError is the validation error returned by
// AckMesssagesResponse.Validate if the designated constraints aren't met.
type AckMesssagesResponseValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e AckMesssagesResponseValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e AckMesssagesResponseValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e AckMesssagesResponseValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e AckMesssagesResponseValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e AckMesssagesResponseValidationError) ErrorName() string {
	return "AckMesssagesResponseValidationError"
}

// Error satisfies the builtin error interface
func (e AckMesssagesResponseValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sAckMesssagesResponse.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = AckMesssagesResponseValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = AckMesssagesResponseValidationError{}

// Validate checks the field values on SendMessageRequest with the rules
// defined in the proto definition for this message. If any rules are
// violated, an error is returned.
func (m *SendMessageRequest) Validate() error {
	if m == nil {
		return nil
	}

	if m.GetMessage() == nil {
		return SendMessageRequestValidationError{
			field:  "Message",
			reason: "value is required",
		}
	}

	if v, ok := interface{}(m.GetMessage()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return SendMessageRequestValidationError{
				field:  "Message",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if m.GetRendezvousKey() == nil {
		return SendMessageRequestValidationError{
			field:  "RendezvousKey",
			reason: "value is required",
		}
	}

	if v, ok := interface{}(m.GetRendezvousKey()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return SendMessageRequestValidationError{
				field:  "RendezvousKey",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if m.GetSignature() == nil {
		return SendMessageRequestValidationError{
			field:  "Signature",
			reason: "value is required",
		}
	}

	if v, ok := interface{}(m.GetSignature()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return SendMessageRequestValidationError{
				field:  "Signature",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	return nil
}

// SendMessageRequestValidationError is the validation error returned by
// SendMessageRequest.Validate if the designated constraints aren't met.
type SendMessageRequestValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e SendMessageRequestValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e SendMessageRequestValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e SendMessageRequestValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e SendMessageRequestValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e SendMessageRequestValidationError) ErrorName() string {
	return "SendMessageRequestValidationError"
}

// Error satisfies the builtin error interface
func (e SendMessageRequestValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sSendMessageRequest.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = SendMessageRequestValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = SendMessageRequestValidationError{}

// Validate checks the field values on SendMessageResponse with the rules
// defined in the proto definition for this message. If any rules are
// violated, an error is returned.
func (m *SendMessageResponse) Validate() error {
	if m == nil {
		return nil
	}

	// no validation rules for Result

	if v, ok := interface{}(m.GetMessageId()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return SendMessageResponseValidationError{
				field:  "MessageId",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	return nil
}

// SendMessageResponseValidationError is the validation error returned by
// SendMessageResponse.Validate if the designated constraints aren't met.
type SendMessageResponseValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e SendMessageResponseValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e SendMessageResponseValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e SendMessageResponseValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e SendMessageResponseValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e SendMessageResponseValidationError) ErrorName() string {
	return "SendMessageResponseValidationError"
}

// Error satisfies the builtin error interface
func (e SendMessageResponseValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sSendMessageResponse.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = SendMessageResponseValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = SendMessageResponseValidationError{}

// Validate checks the field values on RendezvousKey with the rules defined in
// the proto definition for this message. If any rules are violated, an error
// is returned.
func (m *RendezvousKey) Validate() error {
	if m == nil {
		return nil
	}

	if len(m.GetValue()) != 32 {
		return RendezvousKeyValidationError{
			field:  "Value",
			reason: "value length must be 32 bytes",
		}
	}

	return nil
}

// RendezvousKeyValidationError is the validation error returned by
// RendezvousKey.Validate if the designated constraints aren't met.
type RendezvousKeyValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e RendezvousKeyValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e RendezvousKeyValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e RendezvousKeyValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e RendezvousKeyValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e RendezvousKeyValidationError) ErrorName() string { return "RendezvousKeyValidationError" }

// Error satisfies the builtin error interface
func (e RendezvousKeyValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sRendezvousKey.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = RendezvousKeyValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = RendezvousKeyValidationError{}

// Validate checks the field values on MessageId with the rules defined in the
// proto definition for this message. If any rules are violated, an error is returned.
func (m *MessageId) Validate() error {
	if m == nil {
		return nil
	}

	if len(m.GetValue()) != 16 {
		return MessageIdValidationError{
			field:  "Value",
			reason: "value length must be 16 bytes",
		}
	}

	return nil
}

// MessageIdValidationError is the validation error returned by
// MessageId.Validate if the designated constraints aren't met.
type MessageIdValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e MessageIdValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e MessageIdValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e MessageIdValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e MessageIdValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e MessageIdValidationError) ErrorName() string { return "MessageIdValidationError" }

// Error satisfies the builtin error interface
func (e MessageIdValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sMessageId.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = MessageIdValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = MessageIdValidationError{}

// Validate checks the field values on RequestToGrabBill with the rules defined
// in the proto definition for this message. If any rules are violated, an
// error is returned.
func (m *RequestToGrabBill) Validate() error {
	if m == nil {
		return nil
	}

	if m.GetRequestorAccount() == nil {
		return RequestToGrabBillValidationError{
			field:  "RequestorAccount",
			reason: "value is required",
		}
	}

	if v, ok := interface{}(m.GetRequestorAccount()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return RequestToGrabBillValidationError{
				field:  "RequestorAccount",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	return nil
}

// RequestToGrabBillValidationError is the validation error returned by
// RequestToGrabBill.Validate if the designated constraints aren't met.
type RequestToGrabBillValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e RequestToGrabBillValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e RequestToGrabBillValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e RequestToGrabBillValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e RequestToGrabBillValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e RequestToGrabBillValidationError) ErrorName() string {
	return "RequestToGrabBillValidationError"
}

// Error satisfies the builtin error interface
func (e RequestToGrabBillValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sRequestToGrabBill.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = RequestToGrabBillValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = RequestToGrabBillValidationError{}

// Validate checks the field values on RequestToReceiveBill with the rules
// defined in the proto definition for this message. If any rules are
// violated, an error is returned.
func (m *RequestToReceiveBill) Validate() error {
	if m == nil {
		return nil
	}

	if m.GetRequestorAccount() == nil {
		return RequestToReceiveBillValidationError{
			field:  "RequestorAccount",
			reason: "value is required",
		}
	}

	if v, ok := interface{}(m.GetRequestorAccount()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return RequestToReceiveBillValidationError{
				field:  "RequestorAccount",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if v, ok := interface{}(m.GetDomain()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return RequestToReceiveBillValidationError{
				field:  "Domain",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if v, ok := interface{}(m.GetVerifier()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return RequestToReceiveBillValidationError{
				field:  "Verifier",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if v, ok := interface{}(m.GetSignature()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return RequestToReceiveBillValidationError{
				field:  "Signature",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if v, ok := interface{}(m.GetRendezvousKey()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return RequestToReceiveBillValidationError{
				field:  "RendezvousKey",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if len(m.GetAdditionalFees()) > 3 {
		return RequestToReceiveBillValidationError{
			field:  "AdditionalFees",
			reason: "value must contain no more than 3 item(s)",
		}
	}

	for idx, item := range m.GetAdditionalFees() {
		_, _ = idx, item

		if v, ok := interface{}(item).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return RequestToReceiveBillValidationError{
					field:  fmt.Sprintf("AdditionalFees[%v]", idx),
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	}

	switch m.ExchangeData.(type) {

	case *RequestToReceiveBill_Exact:

		if v, ok := interface{}(m.GetExact()).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return RequestToReceiveBillValidationError{
					field:  "Exact",
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	case *RequestToReceiveBill_Partial:

		if v, ok := interface{}(m.GetPartial()).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return RequestToReceiveBillValidationError{
					field:  "Partial",
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	default:
		return RequestToReceiveBillValidationError{
			field:  "ExchangeData",
			reason: "value is required",
		}

	}

	return nil
}

// RequestToReceiveBillValidationError is the validation error returned by
// RequestToReceiveBill.Validate if the designated constraints aren't met.
type RequestToReceiveBillValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e RequestToReceiveBillValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e RequestToReceiveBillValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e RequestToReceiveBillValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e RequestToReceiveBillValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e RequestToReceiveBillValidationError) ErrorName() string {
	return "RequestToReceiveBillValidationError"
}

// Error satisfies the builtin error interface
func (e RequestToReceiveBillValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sRequestToReceiveBill.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = RequestToReceiveBillValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = RequestToReceiveBillValidationError{}

// Validate checks the field values on CodeScanned with the rules defined in
// the proto definition for this message. If any rules are violated, an error
// is returned.
func (m *CodeScanned) Validate() error {
	if m == nil {
		return nil
	}

	if m.GetTimestamp() == nil {
		return CodeScannedValidationError{
			field:  "Timestamp",
			reason: "value is required",
		}
	}

	return nil
}

// CodeScannedValidationError is the validation error returned by
// CodeScanned.Validate if the designated constraints aren't met.
type CodeScannedValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e CodeScannedValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e CodeScannedValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e CodeScannedValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e CodeScannedValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e CodeScannedValidationError) ErrorName() string { return "CodeScannedValidationError" }

// Error satisfies the builtin error interface
func (e CodeScannedValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sCodeScanned.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = CodeScannedValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = CodeScannedValidationError{}

// Validate checks the field values on ClientRejectedPayment with the rules
// defined in the proto definition for this message. If any rules are
// violated, an error is returned.
func (m *ClientRejectedPayment) Validate() error {
	if m == nil {
		return nil
	}

	if m.GetIntentId() == nil {
		return ClientRejectedPaymentValidationError{
			field:  "IntentId",
			reason: "value is required",
		}
	}

	if v, ok := interface{}(m.GetIntentId()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return ClientRejectedPaymentValidationError{
				field:  "IntentId",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	return nil
}

// ClientRejectedPaymentValidationError is the validation error returned by
// ClientRejectedPayment.Validate if the designated constraints aren't met.
type ClientRejectedPaymentValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e ClientRejectedPaymentValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e ClientRejectedPaymentValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e ClientRejectedPaymentValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e ClientRejectedPaymentValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e ClientRejectedPaymentValidationError) ErrorName() string {
	return "ClientRejectedPaymentValidationError"
}

// Error satisfies the builtin error interface
func (e ClientRejectedPaymentValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sClientRejectedPayment.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ClientRejectedPaymentValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = ClientRejectedPaymentValidationError{}

// Validate checks the field values on IntentSubmitted with the rules defined
// in the proto definition for this message. If any rules are violated, an
// error is returned.
func (m *IntentSubmitted) Validate() error {
	if m == nil {
		return nil
	}

	if m.GetIntentId() == nil {
		return IntentSubmittedValidationError{
			field:  "IntentId",
			reason: "value is required",
		}
	}

	if v, ok := interface{}(m.GetIntentId()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return IntentSubmittedValidationError{
				field:  "IntentId",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if v, ok := interface{}(m.GetMetadata()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return IntentSubmittedValidationError{
				field:  "Metadata",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	return nil
}

// IntentSubmittedValidationError is the validation error returned by
// IntentSubmitted.Validate if the designated constraints aren't met.
type IntentSubmittedValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e IntentSubmittedValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e IntentSubmittedValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e IntentSubmittedValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e IntentSubmittedValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e IntentSubmittedValidationError) ErrorName() string { return "IntentSubmittedValidationError" }

// Error satisfies the builtin error interface
func (e IntentSubmittedValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sIntentSubmitted.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = IntentSubmittedValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = IntentSubmittedValidationError{}

// Validate checks the field values on WebhookCalled with the rules defined in
// the proto definition for this message. If any rules are violated, an error
// is returned.
func (m *WebhookCalled) Validate() error {
	if m == nil {
		return nil
	}

	if m.GetTimestamp() == nil {
		return WebhookCalledValidationError{
			field:  "Timestamp",
			reason: "value is required",
		}
	}

	return nil
}

// WebhookCalledValidationError is the validation error returned by
// WebhookCalled.Validate if the designated constraints aren't met.
type WebhookCalledValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e WebhookCalledValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e WebhookCalledValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e WebhookCalledValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e WebhookCalledValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e WebhookCalledValidationError) ErrorName() string { return "WebhookCalledValidationError" }

// Error satisfies the builtin error interface
func (e WebhookCalledValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sWebhookCalled.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = WebhookCalledValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = WebhookCalledValidationError{}

// Validate checks the field values on RequestToLogin with the rules defined in
// the proto definition for this message. If any rules are violated, an error
// is returned.
func (m *RequestToLogin) Validate() error {
	if m == nil {
		return nil
	}

	if m.GetDomain() == nil {
		return RequestToLoginValidationError{
			field:  "Domain",
			reason: "value is required",
		}
	}

	if v, ok := interface{}(m.GetDomain()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return RequestToLoginValidationError{
				field:  "Domain",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if m.GetVerifier() == nil {
		return RequestToLoginValidationError{
			field:  "Verifier",
			reason: "value is required",
		}
	}

	if v, ok := interface{}(m.GetVerifier()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return RequestToLoginValidationError{
				field:  "Verifier",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if m.GetSignature() == nil {
		return RequestToLoginValidationError{
			field:  "Signature",
			reason: "value is required",
		}
	}

	if v, ok := interface{}(m.GetSignature()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return RequestToLoginValidationError{
				field:  "Signature",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if m.GetRendezvousKey() == nil {
		return RequestToLoginValidationError{
			field:  "RendezvousKey",
			reason: "value is required",
		}
	}

	if v, ok := interface{}(m.GetRendezvousKey()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return RequestToLoginValidationError{
				field:  "RendezvousKey",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	return nil
}

// RequestToLoginValidationError is the validation error returned by
// RequestToLogin.Validate if the designated constraints aren't met.
type RequestToLoginValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e RequestToLoginValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e RequestToLoginValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e RequestToLoginValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e RequestToLoginValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e RequestToLoginValidationError) ErrorName() string { return "RequestToLoginValidationError" }

// Error satisfies the builtin error interface
func (e RequestToLoginValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sRequestToLogin.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = RequestToLoginValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = RequestToLoginValidationError{}

// Validate checks the field values on ClientRejectedLogin with the rules
// defined in the proto definition for this message. If any rules are
// violated, an error is returned.
func (m *ClientRejectedLogin) Validate() error {
	if m == nil {
		return nil
	}

	if m.GetTimestamp() == nil {
		return ClientRejectedLoginValidationError{
			field:  "Timestamp",
			reason: "value is required",
		}
	}

	return nil
}

// ClientRejectedLoginValidationError is the validation error returned by
// ClientRejectedLogin.Validate if the designated constraints aren't met.
type ClientRejectedLoginValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e ClientRejectedLoginValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e ClientRejectedLoginValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e ClientRejectedLoginValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e ClientRejectedLoginValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e ClientRejectedLoginValidationError) ErrorName() string {
	return "ClientRejectedLoginValidationError"
}

// Error satisfies the builtin error interface
func (e ClientRejectedLoginValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sClientRejectedLogin.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = ClientRejectedLoginValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = ClientRejectedLoginValidationError{}

// Validate checks the field values on AirdropReceived with the rules defined
// in the proto definition for this message. If any rules are violated, an
// error is returned.
func (m *AirdropReceived) Validate() error {
	if m == nil {
		return nil
	}

	if _, ok := _AirdropReceived_AirdropType_NotInLookup[m.GetAirdropType()]; ok {
		return AirdropReceivedValidationError{
			field:  "AirdropType",
			reason: "value must not be in list [0]",
		}
	}

	if m.GetExchangeData() == nil {
		return AirdropReceivedValidationError{
			field:  "ExchangeData",
			reason: "value is required",
		}
	}

	if v, ok := interface{}(m.GetExchangeData()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return AirdropReceivedValidationError{
				field:  "ExchangeData",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if m.GetTimestamp() == nil {
		return AirdropReceivedValidationError{
			field:  "Timestamp",
			reason: "value is required",
		}
	}

	return nil
}

// AirdropReceivedValidationError is the validation error returned by
// AirdropReceived.Validate if the designated constraints aren't met.
type AirdropReceivedValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e AirdropReceivedValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e AirdropReceivedValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e AirdropReceivedValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e AirdropReceivedValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e AirdropReceivedValidationError) ErrorName() string { return "AirdropReceivedValidationError" }

// Error satisfies the builtin error interface
func (e AirdropReceivedValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sAirdropReceived.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = AirdropReceivedValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = AirdropReceivedValidationError{}

var _AirdropReceived_AirdropType_NotInLookup = map[transaction.AirdropType]struct{}{
	0: {},
}

// Validate checks the field values on Message with the rules defined in the
// proto definition for this message. If any rules are violated, an error is returned.
func (m *Message) Validate() error {
	if m == nil {
		return nil
	}

	if v, ok := interface{}(m.GetId()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return MessageValidationError{
				field:  "Id",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	if v, ok := interface{}(m.GetSendMessageRequestSignature()).(interface{ Validate() error }); ok {
		if err := v.Validate(); err != nil {
			return MessageValidationError{
				field:  "SendMessageRequestSignature",
				reason: "embedded message failed validation",
				cause:  err,
			}
		}
	}

	switch m.Kind.(type) {

	case *Message_RequestToGrabBill:

		if v, ok := interface{}(m.GetRequestToGrabBill()).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return MessageValidationError{
					field:  "RequestToGrabBill",
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	case *Message_RequestToReceiveBill:

		if v, ok := interface{}(m.GetRequestToReceiveBill()).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return MessageValidationError{
					field:  "RequestToReceiveBill",
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	case *Message_CodeScanned:

		if v, ok := interface{}(m.GetCodeScanned()).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return MessageValidationError{
					field:  "CodeScanned",
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	case *Message_ClientRejectedPayment:

		if v, ok := interface{}(m.GetClientRejectedPayment()).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return MessageValidationError{
					field:  "ClientRejectedPayment",
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	case *Message_IntentSubmitted:

		if v, ok := interface{}(m.GetIntentSubmitted()).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return MessageValidationError{
					field:  "IntentSubmitted",
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	case *Message_WebhookCalled:

		if v, ok := interface{}(m.GetWebhookCalled()).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return MessageValidationError{
					field:  "WebhookCalled",
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	case *Message_RequestToLogin:

		if v, ok := interface{}(m.GetRequestToLogin()).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return MessageValidationError{
					field:  "RequestToLogin",
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	case *Message_ClientRejectedLogin:

		if v, ok := interface{}(m.GetClientRejectedLogin()).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return MessageValidationError{
					field:  "ClientRejectedLogin",
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	case *Message_AirdropReceived:

		if v, ok := interface{}(m.GetAirdropReceived()).(interface{ Validate() error }); ok {
			if err := v.Validate(); err != nil {
				return MessageValidationError{
					field:  "AirdropReceived",
					reason: "embedded message failed validation",
					cause:  err,
				}
			}
		}

	default:
		return MessageValidationError{
			field:  "Kind",
			reason: "value is required",
		}

	}

	return nil
}

// MessageValidationError is the validation error returned by Message.Validate
// if the designated constraints aren't met.
type MessageValidationError struct {
	field  string
	reason string
	cause  error
	key    bool
}

// Field function returns field value.
func (e MessageValidationError) Field() string { return e.field }

// Reason function returns reason value.
func (e MessageValidationError) Reason() string { return e.reason }

// Cause function returns cause value.
func (e MessageValidationError) Cause() error { return e.cause }

// Key function returns key value.
func (e MessageValidationError) Key() bool { return e.key }

// ErrorName returns error name.
func (e MessageValidationError) ErrorName() string { return "MessageValidationError" }

// Error satisfies the builtin error interface
func (e MessageValidationError) Error() string {
	cause := ""
	if e.cause != nil {
		cause = fmt.Sprintf(" | caused by: %v", e.cause)
	}

	key := ""
	if e.key {
		key = "key for "
	}

	return fmt.Sprintf(
		"invalid %sMessage.%s: %s%s",
		key,
		e.field,
		e.reason,
		cause)
}

var _ error = MessageValidationError{}

var _ interface {
	Field() string
	Reason() string
	Key() bool
	Cause() error
	ErrorName() string
} = MessageValidationError{}